use libc::FILE;
pub const GRK_UNK_FMT: GRK_SUPPORTED_FILE_FMT = 0;
pub const GRK_J2K_FMT: GRK_SUPPORTED_FILE_FMT = 1;
pub const GRK_JP2_FMT: GRK_SUPPORTED_FILE_FMT = 2;
pub const GRK_PXM_FMT: GRK_SUPPORTED_FILE_FMT = 3;
pub const GRK_PGX_FMT: GRK_SUPPORTED_FILE_FMT = 4;
pub const GRK_PAM_FMT: GRK_SUPPORTED_FILE_FMT = 5;
pub const GRK_BMP_FMT: GRK_SUPPORTED_FILE_FMT = 6;
pub const GRK_TIF_FMT: GRK_SUPPORTED_FILE_FMT = 7;
pub const GRK_RAW_FMT: GRK_SUPPORTED_FILE_FMT = 8;
pub const GRK_PNG_FMT: GRK_SUPPORTED_FILE_FMT = 9;
pub const GRK_RAWL_FMT: GRK_SUPPORTED_FILE_FMT = 10;
pub const GRK_JPG_FMT: GRK_SUPPORTED_FILE_FMT = 11;
pub type GRK_SUPPORTED_FILE_FMT = ::std::os::raw::c_uint;
#[doc = "< place-holder"]
pub const GRK_PROG_UNKNOWN: _GRK_PROG_ORDER = -1;
#[doc = "< layer-resolution-component-precinct order"]
pub const GRK_LRCP: _GRK_PROG_ORDER = 0;
#[doc = "< resolution-layer-component-precinct order"]
pub const GRK_RLCP: _GRK_PROG_ORDER = 1;
#[doc = "< resolution-precinct-component-layer order"]
pub const GRK_RPCL: _GRK_PROG_ORDER = 2;
#[doc = "< precinct-component-resolution-layer order"]
pub const GRK_PCRL: _GRK_PROG_ORDER = 3;
#[doc = "< component-precinct-resolution-layer order"]
pub const GRK_CPRL: _GRK_PROG_ORDER = 4;
pub const GRK_NUM_PROGRESSION_ORDERS: _GRK_PROG_ORDER = 5;
#[doc = " Progression order"]
pub type _GRK_PROG_ORDER = ::std::os::raw::c_int;
#[doc = " Progression order"]
pub use self::_GRK_PROG_ORDER as GRK_PROG_ORDER;
#[doc = "< unknown"]
pub const GRK_CLRSPC_UNKNOWN: _GRK_COLOR_SPACE = 0;
#[doc = "< sRGB"]
pub const GRK_CLRSPC_SRGB: _GRK_COLOR_SPACE = 2;
#[doc = "< grayscale"]
pub const GRK_CLRSPC_GRAY: _GRK_COLOR_SPACE = 3;
#[doc = "< standard YCC (YUV)"]
pub const GRK_CLRSPC_SYCC: _GRK_COLOR_SPACE = 4;
#[doc = "< extended YCC"]
pub const GRK_CLRSPC_EYCC: _GRK_COLOR_SPACE = 5;
#[doc = "< CMYK"]
pub const GRK_CLRSPC_CMYK: _GRK_COLOR_SPACE = 6;
#[doc = "< default CIE LAB"]
pub const GRK_CLRSPC_DEFAULT_CIE: _GRK_COLOR_SPACE = 7;
#[doc = "< custom CIE LAB"]
pub const GRK_CLRSPC_CUSTOM_CIE: _GRK_COLOR_SPACE = 8;
#[doc = "< ICC profile"]
pub const GRK_CLRSPC_ICC: _GRK_COLOR_SPACE = 9;
#[doc = " Supported image color spaces"]
pub type _GRK_COLOR_SPACE = ::std::os::raw::c_uint;
#[doc = " Supported image color spaces"]
pub use self::_GRK_COLOR_SPACE as GRK_COLOR_SPACE;
#[doc = "< place-holder"]
pub const GRK_CODEC_UNKNOWN: _GRK_CODEC_FORMAT = -1;
#[doc = "< JPEG 2000 code stream : read/write"]
pub const GRK_CODEC_J2K: _GRK_CODEC_FORMAT = 0;
#[doc = "< JP2 file format : read/write"]
pub const GRK_CODEC_JP2: _GRK_CODEC_FORMAT = 2;
#[doc = " Supported codecs"]
pub type _GRK_CODEC_FORMAT = ::std::os::raw::c_int;
#[doc = " Supported codecs"]
pub use self::_GRK_CODEC_FORMAT as GRK_CODEC_FORMAT;
pub const GRK_TILE_CACHE_NONE: GRK_TILE_CACHE_STRATEGY = 0;
pub const GRK_TILE_CACHE_ALL: GRK_TILE_CACHE_STRATEGY = 1;
pub type GRK_TILE_CACHE_STRATEGY = ::std::os::raw::c_uint;
#[doc = " Callback function prototype for logging"]
#[doc = ""]
#[doc = " @param msg Event message"]
#[doc = " @param client_data Client object where will be return the event message"]
pub type grk_msg_callback = ::std::option::Option<
unsafe extern "C" fn(
msg: *const ::std::os::raw::c_char,
client_data: *mut ::std::os::raw::c_void,
),
>;
#[doc = " Base Grok ref-counted object"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_object {
pub wrapper: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__grk_object() {
assert_eq!(
::std::mem::size_of::<_grk_object>(),
8usize,
concat!("Size of: ", stringify!(_grk_object))
);
assert_eq!(
::std::mem::align_of::<_grk_object>(),
8usize,
concat!("Alignment of ", stringify!(_grk_object))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_object>())).wrapper as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_object),
"::",
stringify!(wrapper)
)
);
}
#[doc = " Base Grok ref-counted object"]
#[doc = ""]
pub type grk_object = _grk_object;
#[doc = " Progression order change"]
#[doc = ""]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_progression {
#[doc = " progression order bounds specified by POC"]
pub layS: u16,
pub layE: u16,
pub resS: u8,
pub resE: u8,
pub compS: u16,
pub compE: u16,
pub precS: u64,
pub precE: u64,
#[doc = " Progression order enum"]
pub specifiedCompressionPocProg: GRK_PROG_ORDER,
pub progression: GRK_PROG_ORDER,
#[doc = " Progression order string"]
pub progressionString: [::std::os::raw::c_char; 5usize],
#[doc = " Tile number"]
pub tileno: u32,
#[doc = " Start and end values for tile width and height"]
pub tx0: u32,
pub tx1: u32,
pub ty0: u32,
pub ty1: u32,
#[doc = " progression order bounds initialized in pi_create_compress"]
pub tpLayE: u16,
pub tpResS: u8,
pub tpResE: u8,
pub tpCompS: u16,
pub tpCompE: u16,
pub tpPrecE: u64,
#[doc = " tile bounds initialized by pi_create_compress"]
pub tp_txS: u32,
pub tp_txE: u32,
pub tp_tyS: u32,
pub tp_tyE: u32,
pub dx: u32,
pub dy: u32,
#[doc = " tile part temporary values initialized by pi_create_encode"]
pub lay_temp: u16,
pub res_temp: u8,
pub comp_temp: u16,
pub prec_temp: u64,
pub tx0_temp: u32,
pub ty0_temp: u32,
}
#[test]
fn bindgen_test_layout__grk_progression() {
assert_eq!(
::std::mem::size_of::<_grk_progression>(),
136usize,
concat!("Size of: ", stringify!(_grk_progression))
);
assert_eq!(
::std::mem::align_of::<_grk_progression>(),
8usize,
concat!("Alignment of ", stringify!(_grk_progression))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).layS as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(layS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).layE as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(layE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).resS as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(resS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).resE as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(resE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).compS as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(compS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).compE as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(compE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).precS as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(precS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).precE as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(precE)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_progression>())).specifiedCompressionPocProg as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(specifiedCompressionPocProg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).progression as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(progression)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_progression>())).progressionString as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(progressionString)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tileno as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tx0 as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tx0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tx1 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tx1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).ty0 as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(ty0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).ty1 as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(ty1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpLayE as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpLayE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpResS as *const _ as usize },
70usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpResS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpResE as *const _ as usize },
71usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpResE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpCompS as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpCompS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpCompE as *const _ as usize },
74usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpCompE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tpPrecE as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tpPrecE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tp_txS as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tp_txS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tp_txE as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tp_txE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tp_tyS as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tp_tyS)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tp_tyE as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tp_tyE)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).dx as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).dy as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(dy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).lay_temp as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(lay_temp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).res_temp as *const _ as usize },
114usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(res_temp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).comp_temp as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(comp_temp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).prec_temp as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(prec_temp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).tx0_temp as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(tx0_temp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_progression>())).ty0_temp as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(_grk_progression),
"::",
stringify!(ty0_temp)
)
);
}
#[doc = " Progression order change"]
#[doc = ""]
pub type grk_progression = _grk_progression;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_raw_comp_cparameters {
pub dx: u32,
#[doc = " subsampling in X direction"]
pub dy: u32,
}
#[test]
fn bindgen_test_layout__grk_raw_comp_cparameters() {
assert_eq!(
::std::mem::size_of::<_grk_raw_comp_cparameters>(),
8usize,
concat!("Size of: ", stringify!(_grk_raw_comp_cparameters))
);
assert_eq!(
::std::mem::align_of::<_grk_raw_comp_cparameters>(),
4usize,
concat!("Alignment of ", stringify!(_grk_raw_comp_cparameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_comp_cparameters>())).dx as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_comp_cparameters),
"::",
stringify!(dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_comp_cparameters>())).dy as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_comp_cparameters),
"::",
stringify!(dy)
)
);
}
pub type grk_raw_comp_cparameters = _grk_raw_comp_cparameters;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_raw_cparameters {
pub width: u32,
#[doc = " width of the raw image"]
pub height: u32,
#[doc = " height of the raw image"]
pub numcomps: u16,
#[doc = " number of components of the raw image"]
pub prec: u8,
#[doc = " bit depth of the raw image"]
pub sgnd: bool,
#[doc = " signed/unsigned raw image"]
pub comps: *mut grk_raw_comp_cparameters,
}
#[test]
fn bindgen_test_layout__grk_raw_cparameters() {
assert_eq!(
::std::mem::size_of::<_grk_raw_cparameters>(),
24usize,
concat!("Size of: ", stringify!(_grk_raw_cparameters))
);
assert_eq!(
::std::mem::align_of::<_grk_raw_cparameters>(),
8usize,
concat!("Alignment of ", stringify!(_grk_raw_cparameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).width as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).height as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).numcomps as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(numcomps)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).prec as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(prec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).sgnd as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(sgnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_raw_cparameters>())).comps as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_raw_cparameters),
"::",
stringify!(comps)
)
);
}
pub type grk_raw_cparameters = _grk_raw_cparameters;
#[doc = " Compress parameters"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_cparameters {
#[doc = " size of tile: tile_size_on = false (not in argument) or = true (in argument)"]
pub tile_size_on: bool,
#[doc = " XTOsiz"]
pub tx0: u32,
#[doc = " YTOsiz"]
pub ty0: u32,
#[doc = " XTsiz"]
pub t_width: u32,
#[doc = " YTsiz"]
pub t_height: u32,
#[doc = " number of layers"]
pub numlayers: u16,
#[doc = " rate control allocation by rate/distortion curve"]
pub allocationByRateDistoration: bool,
#[doc = " layers rates expressed as compression ratios."]
#[doc = " They might be subsequently limited by the max_cs_size field"]
pub layer_rate: [f64; 100usize],
#[doc = " rate control allocation by fixed_PSNR quality"]
pub allocationByQuality: bool,
#[doc = " layer PSNR values"]
pub layer_distortion: [f64; 100usize],
pub comment: [*mut ::std::os::raw::c_char; 256usize],
pub comment_len: [u16; 256usize],
pub is_binary_comment: [bool; 256usize],
pub num_comments: usize,
#[doc = " csty : coding style"]
pub csty: u8,
pub numgbits: u8,
#[doc = " progression order (default is LRCP)"]
pub prog_order: GRK_PROG_ORDER,
#[doc = " progressions"]
pub progression: [grk_progression; 33usize],
#[doc = " number of progression order changes (POCs), default to 0"]
pub numpocs: u32,
#[doc = " number of resolutions"]
pub numresolution: u8,
#[doc = " initial code block width (default to 64)"]
pub cblockw_init: u32,
#[doc = " initial code block height (default to 64)"]
pub cblockh_init: u32,
#[doc = " code block style"]
pub cblk_sty: u8,
pub isHT: bool,
#[doc = " 1 : use the irreversible DWT 9-7, 0 :"]
#[doc = " use lossless compression (default)"]
pub irreversible: bool,
#[doc = " region of interest: affected component in [0..3];"]
#[doc = " -1 indicates no ROI"]
pub roi_compno: i32,
#[doc = " region of interest: upshift value"]
pub roi_shift: u32,
pub res_spec: u32,
#[doc = " initial precinct width"]
pub prcw_init: [u32; 33usize],
#[doc = " initial precinct height"]
pub prch_init: [u32; 33usize],
#[doc = " input file name"]
pub infile: [::std::os::raw::c_char; 4096usize],
#[doc = " output file name"]
pub outfile: [::std::os::raw::c_char; 4096usize],
#[doc = " subimage compressing: origin image offset in x direction"]
pub image_offset_x0: u32,
#[doc = " subimage compressing: origin image offset in y direction"]
pub image_offset_y0: u32,
#[doc = " subsampling value for dx"]
pub subsampling_dx: u32,
#[doc = " subsampling value for dy"]
pub subsampling_dy: u32,
#[doc = " input file format"]
pub decod_format: GRK_SUPPORTED_FILE_FMT,
#[doc = " output file format"]
pub cod_format: GRK_SUPPORTED_FILE_FMT,
pub raw_cp: grk_raw_cparameters,
#[doc = " Maximum size (in bytes) for each component."]
#[doc = " If == 0, component size limitation is not considered"]
pub max_comp_size: u32,
#[doc = " Tile part generation"]
pub enableTilePartGeneration: bool,
#[doc = " new tile part progression divider"]
pub newTilePartProgressionDivider: u8,
#[doc = " MCT (multiple component transform)"]
pub mct: u8,
#[doc = " Naive implementation of MCT restricted to a single reversible array based"]
#[doc = "compressing without offset concerning all the components."]
pub mct_data: *mut ::std::os::raw::c_void,
#[doc = " Maximum size (in bytes) for the whole code stream."]
#[doc = " If equal to zero, code stream size limitation is not considered"]
#[doc = " If it does not comply with layer_rate, max_cs_size prevails"]
#[doc = " and a warning is issued."]
pub max_cs_size: u64,
#[doc = " RSIZ value"]
#[doc = "To be used to combine GRK_PROFILE_*, GRK_EXTENSION_* and (sub)levels values."]
pub rsiz: u16,
pub framerate: u16,
pub write_capture_resolution_from_file: bool,
pub capture_resolution_from_file: [f64; 2usize],
pub write_capture_resolution: bool,
pub capture_resolution: [f64; 2usize],
pub write_display_resolution: bool,
pub display_resolution: [f64; 2usize],
pub rateControlAlgorithm: u32,
pub numThreads: u32,
pub deviceId: i32,
pub duration: u32,
pub kernelBuildOptions: u32,
pub repeats: u32,
pub writePLT: bool,
pub writeTLM: bool,
pub verbose: bool,
}
#[test]
fn bindgen_test_layout__grk_cparameters() {
assert_eq!(
::std::mem::size_of::<_grk_cparameters>(),
17616usize,
concat!("Size of: ", stringify!(_grk_cparameters))
);
assert_eq!(
::std::mem::align_of::<_grk_cparameters>(),
8usize,
concat!("Alignment of ", stringify!(_grk_cparameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).tile_size_on as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(tile_size_on)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).tx0 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(tx0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).ty0 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(ty0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).t_width as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(t_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).t_height as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(t_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).numlayers as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(numlayers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).allocationByRateDistoration as *const _
as usize
},
22usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(allocationByRateDistoration)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).layer_rate as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(layer_rate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).allocationByQuality as *const _ as usize
},
824usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(allocationByQuality)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).layer_distortion as *const _ as usize
},
832usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(layer_distortion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).comment as *const _ as usize },
1632usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).comment_len as *const _ as usize },
3680usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(comment_len)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).is_binary_comment as *const _ as usize
},
4192usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(is_binary_comment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).num_comments as *const _ as usize },
4448usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(num_comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).csty as *const _ as usize },
4456usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(csty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).numgbits as *const _ as usize },
4457usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(numgbits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).prog_order as *const _ as usize },
4460usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(prog_order)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).progression as *const _ as usize },
4464usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(progression)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).numpocs as *const _ as usize },
8952usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(numpocs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).numresolution as *const _ as usize },
8956usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(numresolution)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).cblockw_init as *const _ as usize },
8960usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(cblockw_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).cblockh_init as *const _ as usize },
8964usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(cblockh_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).cblk_sty as *const _ as usize },
8968usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(cblk_sty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).isHT as *const _ as usize },
8969usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(isHT)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).irreversible as *const _ as usize },
8970usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(irreversible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).roi_compno as *const _ as usize },
8972usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(roi_compno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).roi_shift as *const _ as usize },
8976usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(roi_shift)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).res_spec as *const _ as usize },
8980usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(res_spec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).prcw_init as *const _ as usize },
8984usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(prcw_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).prch_init as *const _ as usize },
9116usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(prch_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).infile as *const _ as usize },
9248usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(infile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).outfile as *const _ as usize },
13344usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(outfile)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).image_offset_x0 as *const _ as usize
},
17440usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(image_offset_x0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).image_offset_y0 as *const _ as usize
},
17444usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(image_offset_y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).subsampling_dx as *const _ as usize },
17448usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(subsampling_dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).subsampling_dy as *const _ as usize },
17452usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(subsampling_dy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).decod_format as *const _ as usize },
17456usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(decod_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).cod_format as *const _ as usize },
17460usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(cod_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).raw_cp as *const _ as usize },
17464usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(raw_cp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).max_comp_size as *const _ as usize },
17488usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(max_comp_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).enableTilePartGeneration as *const _
as usize
},
17492usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(enableTilePartGeneration)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).newTilePartProgressionDivider as *const _
as usize
},
17493usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(newTilePartProgressionDivider)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).mct as *const _ as usize },
17494usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(mct)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).mct_data as *const _ as usize },
17496usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(mct_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).max_cs_size as *const _ as usize },
17504usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(max_cs_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).rsiz as *const _ as usize },
17512usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(rsiz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).framerate as *const _ as usize },
17514usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(framerate)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).write_capture_resolution_from_file
as *const _ as usize
},
17516usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(write_capture_resolution_from_file)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).capture_resolution_from_file as *const _
as usize
},
17520usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(capture_resolution_from_file)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).write_capture_resolution as *const _
as usize
},
17536usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(write_capture_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).capture_resolution as *const _ as usize
},
17544usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(capture_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).write_display_resolution as *const _
as usize
},
17560usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(write_display_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).display_resolution as *const _ as usize
},
17568usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(display_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).rateControlAlgorithm as *const _ as usize
},
17584usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(rateControlAlgorithm)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).numThreads as *const _ as usize },
17588usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(numThreads)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).deviceId as *const _ as usize },
17592usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(deviceId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).duration as *const _ as usize },
17596usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_cparameters>())).kernelBuildOptions as *const _ as usize
},
17600usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(kernelBuildOptions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).repeats as *const _ as usize },
17604usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(repeats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).writePLT as *const _ as usize },
17608usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(writePLT)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).writeTLM as *const _ as usize },
17609usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(writeTLM)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_cparameters>())).verbose as *const _ as usize },
17610usize,
concat!(
"Offset of field: ",
stringify!(_grk_cparameters),
"::",
stringify!(verbose)
)
);
}
#[doc = " Compress parameters"]
pub type grk_cparameters = _grk_cparameters;
#[doc = "Channel definition: channel index, type, association"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_channel_description {
pub cn: u16,
pub typ: u16,
pub asoc: u16,
}
#[test]
fn bindgen_test_layout__grk_channel_description() {
assert_eq!(
::std::mem::size_of::<_grk_channel_description>(),
6usize,
concat!("Size of: ", stringify!(_grk_channel_description))
);
assert_eq!(
::std::mem::align_of::<_grk_channel_description>(),
2usize,
concat!("Alignment of ", stringify!(_grk_channel_description))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_channel_description>())).cn as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_channel_description),
"::",
stringify!(cn)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_channel_description>())).typ as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_grk_channel_description),
"::",
stringify!(typ)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_channel_description>())).asoc as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_channel_description),
"::",
stringify!(asoc)
)
);
}
#[doc = "Channel definition: channel index, type, association"]
pub type grk_channel_description = _grk_channel_description;
#[doc = "Channel definitions and number of definitions"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_channel_definition {
pub descriptions: *mut grk_channel_description,
pub num_channel_descriptions: u16,
}
#[test]
fn bindgen_test_layout__grk_channel_definition() {
assert_eq!(
::std::mem::size_of::<_grk_channel_definition>(),
16usize,
concat!("Size of: ", stringify!(_grk_channel_definition))
);
assert_eq!(
::std::mem::align_of::<_grk_channel_definition>(),
8usize,
concat!("Alignment of ", stringify!(_grk_channel_definition))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_channel_definition>())).descriptions as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_channel_definition),
"::",
stringify!(descriptions)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_channel_definition>())).num_channel_descriptions as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_channel_definition),
"::",
stringify!(num_channel_descriptions)
)
);
}
#[doc = "Channel definitions and number of definitions"]
pub type grk_channel_definition = _grk_channel_definition;
#[doc = "Component mappings: component index, mapping type, palette column"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_component_mapping_comp {
pub component_index: u16,
pub mapping_type: u8,
pub palette_column: u8,
}
#[test]
fn bindgen_test_layout__grk_component_mapping_comp() {
assert_eq!(
::std::mem::size_of::<_grk_component_mapping_comp>(),
4usize,
concat!("Size of: ", stringify!(_grk_component_mapping_comp))
);
assert_eq!(
::std::mem::align_of::<_grk_component_mapping_comp>(),
2usize,
concat!("Alignment of ", stringify!(_grk_component_mapping_comp))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_component_mapping_comp>())).component_index as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_component_mapping_comp),
"::",
stringify!(component_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_component_mapping_comp>())).mapping_type as *const _
as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(_grk_component_mapping_comp),
"::",
stringify!(mapping_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_component_mapping_comp>())).palette_column as *const _
as usize
},
3usize,
concat!(
"Offset of field: ",
stringify!(_grk_component_mapping_comp),
"::",
stringify!(palette_column)
)
);
}
#[doc = "Component mappings: component index, mapping type, palette column"]
pub type grk_component_mapping_comp = _grk_component_mapping_comp;
#[doc = "Palette data"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_palette_data {
pub lut: *mut i32,
pub num_entries: u16,
pub component_mapping: *mut grk_component_mapping_comp,
pub num_channels: u8,
pub channel_sign: *mut bool,
pub channel_prec: *mut u8,
}
#[test]
fn bindgen_test_layout__grk_palette_data() {
assert_eq!(
::std::mem::size_of::<_grk_palette_data>(),
48usize,
concat!("Size of: ", stringify!(_grk_palette_data))
);
assert_eq!(
::std::mem::align_of::<_grk_palette_data>(),
8usize,
concat!("Alignment of ", stringify!(_grk_palette_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_palette_data>())).lut as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(lut)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_palette_data>())).num_entries as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(num_entries)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_palette_data>())).component_mapping as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(component_mapping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_palette_data>())).num_channels as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(num_channels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_palette_data>())).channel_sign as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(channel_sign)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_palette_data>())).channel_prec as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_palette_data),
"::",
stringify!(channel_prec)
)
);
}
#[doc = "Palette data"]
pub type grk_palette_data = _grk_palette_data;
#[doc = "ICC profile, palette, channel definition"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct grk_color {
pub icc_profile_buf: *mut u8,
pub icc_profile_len: u32,
pub channel_definition: *mut grk_channel_definition,
pub palette: *mut grk_palette_data,
pub has_colour_specification_box: bool,
}
#[test]
fn bindgen_test_layout_grk_color() {
assert_eq!(
::std::mem::size_of::<grk_color>(),
40usize,
concat!("Size of: ", stringify!(grk_color))
);
assert_eq!(
::std::mem::align_of::<grk_color>(),
8usize,
concat!("Alignment of ", stringify!(grk_color))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_color>())).icc_profile_buf as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(grk_color),
"::",
stringify!(icc_profile_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_color>())).icc_profile_len as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(grk_color),
"::",
stringify!(icc_profile_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_color>())).channel_definition as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(grk_color),
"::",
stringify!(channel_definition)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_color>())).palette as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(grk_color),
"::",
stringify!(palette)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_color>())).has_colour_specification_box as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(grk_color),
"::",
stringify!(has_colour_specification_box)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct grk_asoc {
pub level: u32,
pub label: *const ::std::os::raw::c_char,
pub xml: *mut u8,
pub xml_len: u32,
}
#[test]
fn bindgen_test_layout_grk_asoc() {
assert_eq!(
::std::mem::size_of::<grk_asoc>(),
32usize,
concat!("Size of: ", stringify!(grk_asoc))
);
assert_eq!(
::std::mem::align_of::<grk_asoc>(),
8usize,
concat!("Alignment of ", stringify!(grk_asoc))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_asoc>())).level as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(grk_asoc),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_asoc>())).label as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(grk_asoc),
"::",
stringify!(label)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_asoc>())).xml as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(grk_asoc),
"::",
stringify!(xml)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<grk_asoc>())).xml_len as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(grk_asoc),
"::",
stringify!(xml_len)
)
);
}
#[doc = " Header info"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_header_info {
#[doc = " initial code block width, default to 64"]
pub cblockw_init: u32,
#[doc = " initial code block height, default to 64"]
pub cblockh_init: u32,
#[doc = " 1 : use the irreversible DWT 9-7, 0 : use lossless compression (default)"]
pub irreversible: bool,
#[doc = " multi-component transform identifier"]
pub mct: u32,
#[doc = " RSIZ value"]
#[doc = "To be used to combine GRK_PROFILE_*, GRK_EXTENSION_* and (sub)levels values."]
pub rsiz: u16,
#[doc = " number of resolutions"]
pub numresolutions: u32,
pub csty: u8,
pub cblk_sty: u8,
#[doc = " initial precinct width"]
pub prcw_init: [u32; 33usize],
#[doc = " initial precinct height"]
pub prch_init: [u32; 33usize],
#[doc = " XTOsiz"]
pub tx0: u32,
#[doc = " YTOsiz"]
pub ty0: u32,
#[doc = " XTsiz"]
pub t_width: u32,
#[doc = " YTsiz"]
pub t_height: u32,
#[doc = " tile grid width"]
pub t_grid_width: u32,
#[doc = " tile grid height"]
pub t_grid_height: u32,
#[doc = " number of layers"]
pub numlayers: u16,
pub xml_data: *mut u8,
pub xml_data_len: usize,
pub num_comments: usize,
pub comment: [*mut ::std::os::raw::c_char; 256usize],
pub comment_len: [u16; 256usize],
pub isBinaryComment: [bool; 256usize],
pub asocs: [grk_asoc; 256usize],
pub num_asocs: u32,
}
#[test]
fn bindgen_test_layout__grk_header_info() {
assert_eq!(
::std::mem::size_of::<_grk_header_info>(),
11360usize,
concat!("Size of: ", stringify!(_grk_header_info))
);
assert_eq!(
::std::mem::align_of::<_grk_header_info>(),
8usize,
concat!("Alignment of ", stringify!(_grk_header_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).cblockw_init as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(cblockw_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).cblockh_init as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(cblockh_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).irreversible as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(irreversible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).mct as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(mct)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).rsiz as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(rsiz)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).numresolutions as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(numresolutions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).csty as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(csty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).cblk_sty as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(cblk_sty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).prcw_init as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(prcw_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).prch_init as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(prch_init)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).tx0 as *const _ as usize },
292usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(tx0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).ty0 as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(ty0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).t_width as *const _ as usize },
300usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(t_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).t_height as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(t_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).t_grid_width as *const _ as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(t_grid_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).t_grid_height as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(t_grid_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).numlayers as *const _ as usize },
316usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(numlayers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).xml_data as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(xml_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).xml_data_len as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(xml_data_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).num_comments as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(num_comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).comment as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).comment_len as *const _ as usize },
2392usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(comment_len)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_header_info>())).isBinaryComment as *const _ as usize
},
2904usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(isBinaryComment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).asocs as *const _ as usize },
3160usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(asocs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_header_info>())).num_asocs as *const _ as usize },
11352usize,
concat!(
"Offset of field: ",
stringify!(_grk_header_info),
"::",
stringify!(num_asocs)
)
);
}
#[doc = " Header info"]
pub type grk_header_info = _grk_header_info;
#[doc = " Core decompress parameters"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_dparameters {
#[doc = "Set the number of highest resolution levels to be discarded."]
#[doc = "The image resolution is effectively divided by 2 to the power of the number of discarded"]
#[doc = "levels. The reduce factor is limited by the smallest total number of decomposition levels among"]
#[doc = "tiles. if greater than zero, then image is decoded to original dimension divided by"]
#[doc = "2^(cp_reduce); if equal to zero or not used, image is decompressed to full resolution"]
pub cp_reduce: u8,
#[doc = "Set the maximum number of quality layers to decompress."]
#[doc = "If there are fewer quality layers than the specified number, all quality layers will be"]
#[doc = "decompressed. if != 0, then only the first \"layer\" layers are decompressed; if == 0 or not"]
#[doc = "used, all the quality layers are decompressed"]
pub cp_layer: u16,
#[doc = " input file name"]
pub infile: [::std::os::raw::c_char; 4096usize],
#[doc = " output file name"]
pub outfile: [::std::os::raw::c_char; 4096usize],
#[doc = " input file format"]
pub decod_format: GRK_SUPPORTED_FILE_FMT,
#[doc = " output file format"]
pub cod_format: GRK_SUPPORTED_FILE_FMT,
#[doc = " Decompress window left boundary"]
pub DA_x0: u32,
#[doc = " Decompress window right boundary"]
pub DA_x1: u32,
#[doc = " Decompress window up boundary"]
pub DA_y0: u32,
#[doc = " Decompress window bottom boundary"]
pub DA_y1: u32,
#[doc = " Verbose mode"]
pub m_verbose: bool,
#[doc = " tile number of the decompressed tile"]
pub tileIndex: u16,
#[doc = " Number of tiles to decompress"]
pub nb_tile_to_decompress: u32,
pub flags: u32,
pub tileCacheStrategy: GRK_TILE_CACHE_STRATEGY,
}
#[test]
fn bindgen_test_layout__grk_dparameters() {
assert_eq!(
::std::mem::size_of::<_grk_dparameters>(),
8236usize,
concat!("Size of: ", stringify!(_grk_dparameters))
);
assert_eq!(
::std::mem::align_of::<_grk_dparameters>(),
4usize,
concat!("Alignment of ", stringify!(_grk_dparameters))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).cp_reduce as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(cp_reduce)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).cp_layer as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(cp_layer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).infile as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(infile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).outfile as *const _ as usize },
4100usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(outfile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).decod_format as *const _ as usize },
8196usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(decod_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).cod_format as *const _ as usize },
8200usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(cod_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).DA_x0 as *const _ as usize },
8204usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(DA_x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).DA_x1 as *const _ as usize },
8208usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(DA_x1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).DA_y0 as *const _ as usize },
8212usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(DA_y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).DA_y1 as *const _ as usize },
8216usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(DA_y1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).m_verbose as *const _ as usize },
8220usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(m_verbose)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).tileIndex as *const _ as usize },
8222usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(tileIndex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_dparameters>())).nb_tile_to_decompress as *const _ as usize
},
8224usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(nb_tile_to_decompress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_dparameters>())).flags as *const _ as usize },
8228usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_dparameters>())).tileCacheStrategy as *const _ as usize
},
8232usize,
concat!(
"Offset of field: ",
stringify!(_grk_dparameters),
"::",
stringify!(tileCacheStrategy)
)
);
}
#[doc = " Core decompress parameters"]
pub type grk_dparameters = _grk_dparameters;
pub const GRK_PREC_MODE_CLIP: grk_prec_mode = 0;
pub const GRK_PREC_MODE_SCALE: grk_prec_mode = 1;
#[doc = " Precision mode"]
pub type grk_prec_mode = ::std::os::raw::c_uint;
#[doc = " Precision mode"]
pub use self::grk_prec_mode as grk_precision_mode;
#[doc = " Precision"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_prec {
pub prec: u8,
pub mode: grk_precision_mode,
}
#[test]
fn bindgen_test_layout__grk_prec() {
assert_eq!(
::std::mem::size_of::<_grk_prec>(),
8usize,
concat!("Size of: ", stringify!(_grk_prec))
);
assert_eq!(
::std::mem::align_of::<_grk_prec>(),
4usize,
concat!("Alignment of ", stringify!(_grk_prec))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_prec>())).prec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_prec),
"::",
stringify!(prec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_prec>())).mode as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_prec),
"::",
stringify!(mode)
)
);
}
#[doc = " Precision"]
pub type grk_precision = _grk_prec;
#[doc = " Decompress parameters"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_decompress_params {
#[doc = " core library parameters"]
pub core: grk_dparameters,
#[doc = " input file name"]
pub infile: [::std::os::raw::c_char; 4096usize],
#[doc = " output file name"]
pub outfile: [::std::os::raw::c_char; 4096usize],
#[doc = " input file format 0: J2K, 1: JP2"]
pub decod_format: GRK_SUPPORTED_FILE_FMT,
#[doc = " output file format 0: PGX, 1: PxM, 2: BMP"]
pub cod_format: GRK_SUPPORTED_FILE_FMT,
#[doc = " index file name"]
pub indexfilename: [::std::os::raw::c_char; 4096usize],
#[doc = " Decompress window left boundary"]
pub DA_x0: u32,
#[doc = " Decompress window right boundary"]
pub DA_x1: u32,
#[doc = " Decompress window up boundary"]
pub DA_y0: u32,
#[doc = " Decompress window bottom boundary"]
pub DA_y1: u32,
#[doc = " Verbose mode"]
pub m_verbose: bool,
#[doc = " tile number of the decompressed tile"]
pub tileIndex: u16,
#[doc = " Number of tiles to decompress"]
pub nb_tile_to_decompress: u32,
pub precision: *mut grk_precision,
pub nb_precision: u32,
pub force_rgb: bool,
pub upsample: bool,
pub split_pnm: bool,
pub serialize_xml: bool,
pub compression: u32,
pub compressionLevel: u32,
pub deviceId: i32,
pub duration: u32,
pub kernelBuildOptions: u32,
pub repeats: u32,
pub verbose: bool,
pub numThreads: u32,
}
#[test]
fn bindgen_test_layout__grk_decompress_params() {
assert_eq!(
::std::mem::size_of::<_grk_decompress_params>(),
20608usize,
concat!("Size of: ", stringify!(_grk_decompress_params))
);
assert_eq!(
::std::mem::align_of::<_grk_decompress_params>(),
8usize,
concat!("Alignment of ", stringify!(_grk_decompress_params))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).core as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(core)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).infile as *const _ as usize },
8236usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(infile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).outfile as *const _ as usize },
12332usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(outfile)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).decod_format as *const _ as usize
},
16428usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(decod_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).cod_format as *const _ as usize
},
16432usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(cod_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).indexfilename as *const _ as usize
},
16436usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(indexfilename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).DA_x0 as *const _ as usize },
20532usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(DA_x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).DA_x1 as *const _ as usize },
20536usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(DA_x1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).DA_y0 as *const _ as usize },
20540usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(DA_y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).DA_y1 as *const _ as usize },
20544usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(DA_y1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).m_verbose as *const _ as usize
},
20548usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(m_verbose)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).tileIndex as *const _ as usize
},
20550usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(tileIndex)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).nb_tile_to_decompress as *const _
as usize
},
20552usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(nb_tile_to_decompress)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).precision as *const _ as usize
},
20560usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(precision)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).nb_precision as *const _ as usize
},
20568usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(nb_precision)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).force_rgb as *const _ as usize
},
20572usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(force_rgb)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).upsample as *const _ as usize },
20573usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(upsample)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).split_pnm as *const _ as usize
},
20574usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(split_pnm)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).serialize_xml as *const _ as usize
},
20575usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(serialize_xml)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).compression as *const _ as usize
},
20576usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(compression)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).compressionLevel as *const _ as usize
},
20580usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(compressionLevel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).deviceId as *const _ as usize },
20584usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(deviceId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).duration as *const _ as usize },
20588usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(duration)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).kernelBuildOptions as *const _
as usize
},
20592usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(kernelBuildOptions)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).repeats as *const _ as usize },
20596usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(repeats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_decompress_params>())).verbose as *const _ as usize },
20600usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(verbose)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_decompress_params>())).numThreads as *const _ as usize
},
20604usize,
concat!(
"Offset of field: ",
stringify!(_grk_decompress_params),
"::",
stringify!(numThreads)
)
);
}
#[doc = " Decompress parameters"]
pub type grk_decompress_parameters = _grk_decompress_params;
pub type grk_codec = grk_object;
pub type grk_stream_read_fn = ::std::option::Option<
unsafe extern "C" fn(
buffer: *mut ::std::os::raw::c_void,
numBytes: usize,
user_data: *mut ::std::os::raw::c_void,
) -> usize,
>;
pub type grk_stream_write_fn = ::std::option::Option<
unsafe extern "C" fn(
buffer: *mut ::std::os::raw::c_void,
numBytes: usize,
user_data: *mut ::std::os::raw::c_void,
) -> usize,
>;
pub type grk_stream_seek_fn = ::std::option::Option<
unsafe extern "C" fn(numBytes: u64, user_data: *mut ::std::os::raw::c_void) -> bool,
>;
pub type grk_stream_free_user_data_fn =
::std::option::Option<unsafe extern "C" fn(user_data: *mut ::std::os::raw::c_void)>;
pub type grk_stream = grk_object;
pub const GRK_COMPONENT_TYPE_COLOUR: GRK_COMPONENT_TYPE = 0;
pub const GRK_COMPONENT_TYPE_OPACITY: GRK_COMPONENT_TYPE = 1;
pub const GRK_COMPONENT_TYPE_PREMULTIPLIED_OPACITY: GRK_COMPONENT_TYPE = 2;
pub const GRK_COMPONENT_TYPE_UNSPECIFIED: GRK_COMPONENT_TYPE = 65535;
pub type GRK_COMPONENT_TYPE = ::std::os::raw::c_uint;
pub const GRK_COMPONENT_ASSOC_WHOLE_IMAGE: GRK_COMPONENT_ASSOC = 0;
pub const GRK_COMPONENT_ASSOC_COLOUR_1: GRK_COMPONENT_ASSOC = 1;
pub const GRK_COMPONENT_ASSOC_COLOUR_2: GRK_COMPONENT_ASSOC = 2;
pub const GRK_COMPONENT_ASSOC_COLOUR_3: GRK_COMPONENT_ASSOC = 3;
pub const GRK_COMPONENT_ASSOC_UNASSOCIATED: GRK_COMPONENT_ASSOC = 65535;
pub type GRK_COMPONENT_ASSOC = ::std::os::raw::c_uint;
#[doc = " Image component"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_image_comp {
pub obj: grk_object,
#[doc = " XRsiz: horizontal separation of a sample of with component with respect to the reference"]
#[doc = " grid"]
pub dx: u32,
#[doc = " YRsiz: vertical separation of a sample of with component with respect to the reference grid"]
pub dy: u32,
#[doc = " data width"]
pub w: u32,
#[doc = " data stride"]
pub stride: u32,
#[doc = " data height"]
pub h: u32,
#[doc = " x component offset compared to the whole image"]
pub x0: u32,
#[doc = " y component offset compared to the whole image"]
pub y0: u32,
pub Xcrg: u16,
pub Ycrg: u16,
#[doc = " precision"]
pub prec: u8,
pub sgnd: bool,
#[doc = " image component data"]
pub data: *mut i32,
pub type_: GRK_COMPONENT_TYPE,
pub association: GRK_COMPONENT_ASSOC,
}
#[test]
fn bindgen_test_layout__grk_image_comp() {
assert_eq!(
::std::mem::size_of::<_grk_image_comp>(),
64usize,
concat!("Size of: ", stringify!(_grk_image_comp))
);
assert_eq!(
::std::mem::align_of::<_grk_image_comp>(),
8usize,
concat!("Alignment of ", stringify!(_grk_image_comp))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).obj as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).dx as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).dy as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(dy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).w as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).stride as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).h as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).x0 as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).y0 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).Xcrg as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(Xcrg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).Ycrg as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(Ycrg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).prec as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(prec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).sgnd as *const _ as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(sgnd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).data as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).type_ as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comp>())).association as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comp),
"::",
stringify!(association)
)
);
}
#[doc = " Image component"]
pub type grk_image_comp = _grk_image_comp;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_image_meta {
pub obj: grk_object,
pub color: grk_color,
pub iptc_buf: *mut u8,
pub iptc_len: usize,
pub xmp_buf: *mut u8,
pub xmp_len: usize,
}
#[test]
fn bindgen_test_layout__grk_image_meta() {
assert_eq!(
::std::mem::size_of::<_grk_image_meta>(),
80usize,
concat!("Size of: ", stringify!(_grk_image_meta))
);
assert_eq!(
::std::mem::align_of::<_grk_image_meta>(),
8usize,
concat!("Alignment of ", stringify!(_grk_image_meta))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).obj as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).color as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).iptc_buf as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(iptc_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).iptc_len as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(iptc_len)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).xmp_buf as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(xmp_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_meta>())).xmp_len as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_meta),
"::",
stringify!(xmp_len)
)
);
}
pub type grk_image_meta = _grk_image_meta;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_image {
pub obj: grk_object,
#[doc = " XOsiz: horizontal offset from the origin of the reference grid"]
#[doc = " to the left side of the image area"]
pub x0: u32,
#[doc = " YOsiz: vertical offset from the origin of the reference grid"]
#[doc = " to the top side of the image area"]
pub y0: u32,
#[doc = " Xsiz: width of the reference grid"]
pub x1: u32,
#[doc = " Ysiz: height of the reference grid"]
pub y1: u32,
#[doc = " number of components in the image"]
pub numcomps: u16,
pub color_space: GRK_COLOR_SPACE,
pub color_applied: bool,
pub has_capture_resolution: bool,
pub capture_resolution: [f64; 2usize],
pub has_display_resolution: bool,
pub display_resolution: [f64; 2usize],
pub meta: *mut grk_image_meta,
pub comps: *mut grk_image_comp,
}
#[test]
fn bindgen_test_layout__grk_image() {
assert_eq!(
::std::mem::size_of::<_grk_image>(),
96usize,
concat!("Size of: ", stringify!(_grk_image))
);
assert_eq!(
::std::mem::align_of::<_grk_image>(),
8usize,
concat!("Alignment of ", stringify!(_grk_image))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).obj as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(obj)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).x0 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).y0 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).x1 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(x1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).y1 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(y1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).numcomps as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(numcomps)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).color_space as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(color_space)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).color_applied as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(color_applied)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_image>())).has_capture_resolution as *const _ as usize
},
33usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(has_capture_resolution)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).capture_resolution as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(capture_resolution)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_image>())).has_display_resolution as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(has_display_resolution)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).display_resolution as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(display_resolution)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).meta as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(meta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image>())).comps as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_grk_image),
"::",
stringify!(comps)
)
);
}
pub type grk_image = _grk_image;
#[doc = " Image component parameters"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_image_comptparm {
#[doc = " XRsiz: horizontal separation of a sample of component"]
#[doc = " with respect to the reference grid"]
pub dx: u32,
#[doc = " YRsiz: vertical separation of a sample of component"]
#[doc = " with respect to the reference grid"]
pub dy: u32,
#[doc = " data width"]
pub w: u32,
pub stride: u32,
#[doc = " data height"]
pub h: u32,
#[doc = " x component offset compared to the whole image"]
pub x0: u32,
#[doc = " y component offset compared to the whole image"]
pub y0: u32,
#[doc = " precision"]
pub prec: u8,
#[doc = " true if data is signed"]
pub sgnd: bool,
}
#[test]
fn bindgen_test_layout__grk_image_comptparm() {
assert_eq!(
::std::mem::size_of::<_grk_image_comptparm>(),
32usize,
concat!("Size of: ", stringify!(_grk_image_comptparm))
);
assert_eq!(
::std::mem::align_of::<_grk_image_comptparm>(),
4usize,
concat!("Alignment of ", stringify!(_grk_image_comptparm))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).dx as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(dx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).dy as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(dy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).stride as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(stride)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).h as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).x0 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).y0 as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).prec as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(prec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_image_comptparm>())).sgnd as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(_grk_image_comptparm),
"::",
stringify!(sgnd)
)
);
}
#[doc = " Image component parameters"]
pub type grk_image_cmptparm = _grk_image_comptparm;
#[doc = " Plugin pass"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_pass {
pub distortionDecrease: f64,
pub rate: usize,
pub length: usize,
}
#[test]
fn bindgen_test_layout__grk_plugin_pass() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_pass>(),
24usize,
concat!("Size of: ", stringify!(_grk_plugin_pass))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_pass>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_pass))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_pass>())).distortionDecrease as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_pass),
"::",
stringify!(distortionDecrease)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_pass>())).rate as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_pass),
"::",
stringify!(rate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_pass>())).length as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_pass),
"::",
stringify!(length)
)
);
}
#[doc = " Plugin pass"]
pub type grk_plugin_pass = _grk_plugin_pass;
#[doc = " Plugin code block"]
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_plugin_code_block {
#[doc = ""]
pub x0: u32,
#[doc = ""]
pub y0: u32,
#[doc = ""]
pub x1: u32,
#[doc = ""]
pub y1: u32,
pub contextStream: *mut ::std::os::raw::c_uint,
#[doc = ""]
pub numPix: u32,
pub compressedData: *mut u8,
pub compressedDataLength: u32,
pub numBitPlanes: u8,
pub numPasses: usize,
pub passes: [grk_plugin_pass; 67usize],
pub sortedIndex: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout__grk_plugin_code_block() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_code_block>(),
1672usize,
concat!("Size of: ", stringify!(_grk_plugin_code_block))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_code_block>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_code_block))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).x0 as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).y0 as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).x1 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(x1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).y1 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(y1)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).contextStream as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(contextStream)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).numPix as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(numPix)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).compressedData as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(compressedData)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).compressedDataLength as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(compressedDataLength)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).numBitPlanes as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(numBitPlanes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).numPasses as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(numPasses)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_code_block>())).passes as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(passes)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_code_block>())).sortedIndex as *const _ as usize
},
1664usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_code_block),
"::",
stringify!(sortedIndex)
)
);
}
#[doc = " Plugin code block"]
pub type grk_plugin_code_block = _grk_plugin_code_block;
#[doc = " Plugin precinct"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_precinct {
pub numBlocks: u64,
pub blocks: *mut *mut grk_plugin_code_block,
}
#[test]
fn bindgen_test_layout__grk_plugin_precinct() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_precinct>(),
16usize,
concat!("Size of: ", stringify!(_grk_plugin_precinct))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_precinct>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_precinct))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_precinct>())).numBlocks as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_precinct),
"::",
stringify!(numBlocks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_precinct>())).blocks as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_precinct),
"::",
stringify!(blocks)
)
);
}
#[doc = " Plugin precinct"]
pub type grk_plugin_precinct = _grk_plugin_precinct;
#[doc = " Plugin band"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_band {
pub orientation: u8,
pub numPrecincts: u64,
pub precincts: *mut *mut grk_plugin_precinct,
pub stepsize: f32,
}
#[test]
fn bindgen_test_layout__grk_plugin_band() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_band>(),
32usize,
concat!("Size of: ", stringify!(_grk_plugin_band))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_band>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_band))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_band>())).orientation as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_band),
"::",
stringify!(orientation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_band>())).numPrecincts as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_band),
"::",
stringify!(numPrecincts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_band>())).precincts as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_band),
"::",
stringify!(precincts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_band>())).stepsize as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_band),
"::",
stringify!(stepsize)
)
);
}
#[doc = " Plugin band"]
pub type grk_plugin_band = _grk_plugin_band;
#[doc = " Plugin resolution"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_resolution {
pub level: usize,
pub numBands: usize,
pub band: *mut *mut grk_plugin_band,
}
#[test]
fn bindgen_test_layout__grk_plugin_resolution() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_resolution>(),
24usize,
concat!("Size of: ", stringify!(_grk_plugin_resolution))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_resolution>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_resolution))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_resolution>())).level as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_resolution),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_resolution>())).numBands as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_resolution),
"::",
stringify!(numBands)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_resolution>())).band as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_resolution),
"::",
stringify!(band)
)
);
}
#[doc = " Plugin resolution"]
pub type grk_plugin_resolution = _grk_plugin_resolution;
#[doc = " Plugin tile component"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct grk_plugin_tile_component {
pub numResolutions: usize,
pub resolutions: *mut *mut grk_plugin_resolution,
}
#[test]
fn bindgen_test_layout_grk_plugin_tile_component() {
assert_eq!(
::std::mem::size_of::<grk_plugin_tile_component>(),
16usize,
concat!("Size of: ", stringify!(grk_plugin_tile_component))
);
assert_eq!(
::std::mem::align_of::<grk_plugin_tile_component>(),
8usize,
concat!("Alignment of ", stringify!(grk_plugin_tile_component))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_tile_component>())).numResolutions as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_tile_component),
"::",
stringify!(numResolutions)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_tile_component>())).resolutions as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_tile_component),
"::",
stringify!(resolutions)
)
);
}
#[doc = " Plugin tile"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_tile {
pub decompress_flags: u32,
pub numComponents: usize,
pub tileComponents: *mut *mut grk_plugin_tile_component,
}
#[test]
fn bindgen_test_layout__grk_plugin_tile() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_tile>(),
24usize,
concat!("Size of: ", stringify!(_grk_plugin_tile))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_tile>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_tile))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_tile>())).decompress_flags as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_tile),
"::",
stringify!(decompress_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_tile>())).numComponents as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_tile),
"::",
stringify!(numComponents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_tile>())).tileComponents as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_tile),
"::",
stringify!(tileComponents)
)
);
}
#[doc = " Plugin tile"]
pub type grk_plugin_tile = _grk_plugin_tile;
extern "C" {
#[doc = " library version"]
pub fn grk_version() -> *const ::std::os::raw::c_char;
}
extern "C" {
#[doc = " Initialize library"]
#[doc = ""]
#[doc = " @param pluginPath \tpath to plugin"]
#[doc = " @param numthreads \tnumber of threads to use for compress/decompress"]
pub fn grk_initialize(pluginPath: *const ::std::os::raw::c_char, numthreads: u32) -> bool;
}
extern "C" {
#[doc = " De-initialize library"]
pub fn grk_deinitialize();
}
extern "C" {
#[doc = " Increment ref count"]
pub fn grk_object_ref(obj: *mut grk_object);
}
extern "C" {
pub fn grk_object_unref(obj: *mut grk_object);
}
extern "C" {
#[doc = " Set info handler"]
#[doc = ""]
#[doc = " @param p_callback the callback function which will be used"]
#[doc = " @param user_data client object where will be returned the message"]
pub fn grk_set_info_handler(
p_callback: grk_msg_callback,
user_data: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Set warning handler"]
#[doc = ""]
#[doc = " @param p_callback the callback function which will be used"]
#[doc = " @param user_data client object where will be returned the message"]
pub fn grk_set_warning_handler(
p_callback: grk_msg_callback,
user_data: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Set error handler"]
#[doc = ""]
#[doc = " @param p_callback the callback function which will be used"]
#[doc = " @param user_data client object where will be returned the message"]
pub fn grk_set_error_handler(
p_callback: grk_msg_callback,
user_data: *mut ::std::os::raw::c_void,
) -> bool;
}
extern "C" {
#[doc = " Create image"]
#[doc = ""]
#[doc = " @param numcmpts number of components"]
#[doc = " @param cmptparms component parameters"]
#[doc = " @param clrspc image color space"]
#[doc = " @param allocData\t\ttrue if data is to be allocated, otherwise false"]
#[doc = ""]
#[doc = " @return returns a new image if successful, otherwise nullptr"]
pub fn grk_image_new(
numcmpts: u16,
cmptparms: *mut grk_image_cmptparm,
clrspc: GRK_COLOR_SPACE,
allocData: bool,
) -> *mut grk_image;
}
extern "C" {
pub fn grk_image_meta_new() -> *mut grk_image_meta;
}
extern "C" {
#[doc = " Deallocate all component data for an image"]
#[doc = ""]
#[doc = " @param image image"]
pub fn grk_image_all_components_data_free(image: *mut grk_image);
}
extern "C" {
#[doc = " Deallocate data for single image component"]
#[doc = ""]
#[doc = " @param image image"]
pub fn grk_image_single_component_data_free(image: *mut grk_image_comp);
}
extern "C" {
#[doc = " Create an abstract stream. This function does nothing except"]
#[doc = " allocate memory and initialize abstract stream."]
#[doc = ""]
#[doc = " @param\tbuffer_size size of stream's double-buffer"]
#[doc = " @param\tis_input\t if set to true then the stream will be"]
#[doc = " an input stream, an output stream else."]
#[doc = ""]
#[doc = " @return\tstream object."]
pub fn grk_stream_new(buffer_size: usize, is_input: bool) -> *mut grk_stream;
}
extern "C" {
#[doc = " Set the given function to be used as a read function."]
#[doc = ""]
#[doc = " @param\t\tstream\tthe stream to modify"]
#[doc = " @param\t\tp_function\tthe function to use a read function."]
pub fn grk_stream_set_read_function(stream: *mut grk_stream, p_function: grk_stream_read_fn);
}
extern "C" {
#[doc = " Set the given function to be used as a write function."]
#[doc = ""]
#[doc = " @param\t\tstream\tthe stream to modify"]
#[doc = " @param\t\tp_function\tthe function to use a write function."]
pub fn grk_stream_set_write_function(stream: *mut grk_stream, p_function: grk_stream_write_fn);
}
extern "C" {
#[doc = " Set the given function to be used as a seek function, the stream is then seekable."]
#[doc = ""]
#[doc = " @param\t\tstream\tthe stream to modify"]
#[doc = " @param\t\tp_function\tthe function to use a skip function."]
pub fn grk_stream_set_seek_function(stream: *mut grk_stream, p_function: grk_stream_seek_fn);
}
extern "C" {
#[doc = " Set the given data to be used as a user data for the stream."]
#[doc = ""]
#[doc = " @param\t\tstream\tthe stream to modify"]
#[doc = " @param\t\tdata\t\tthe data to set."]
#[doc = " @param\t\tp_function\tthe function to free data when grk_object_unref() is called."]
pub fn grk_stream_set_user_data(
stream: *mut grk_stream,
data: *mut ::std::os::raw::c_void,
p_function: grk_stream_free_user_data_fn,
);
}
extern "C" {
#[doc = " Set the length of the user data for the stream."]
#[doc = ""]
#[doc = " @param stream the stream to modify"]
#[doc = " @param data_length length of the user_data."]
pub fn grk_stream_set_user_data_length(stream: *mut grk_stream, data_length: u64);
}
extern "C" {
#[doc = " Create stream from a file identified with its filename with a specific buffer size"]
#[doc = ""]
#[doc = " @param fname the filename of the file to stream"]
#[doc = " @param buffer_size size of the chunk used to stream"]
#[doc = " @param is_read_stream whether the stream is a read stream (true) or not (false)"]
pub fn grk_stream_create_file_stream(
fname: *const ::std::os::raw::c_char,
buffer_size: usize,
is_read_stream: bool,
) -> *mut grk_stream;
}
extern "C" {
#[doc = " Create stream from buffer"]
#[doc = ""]
#[doc = " @param buf\t\t\tbuffer"]
#[doc = " @param buffer_len length of buffer"]
#[doc = " @param ownsBuffer\tif true, library will delete[] buffer. Otherwise, it is the caller's"]
#[doc = "\t\t\t\t\t\tresponsibility to delete the buffer"]
#[doc = " @param is_read_stream whether the stream is a read stream (true) or not (false)"]
pub fn grk_stream_create_mem_stream(
buf: *mut u8,
buffer_len: usize,
ownsBuffer: bool,
is_read_stream: bool,
) -> *mut grk_stream;
}
extern "C" {
#[doc = " Get length of memory stream"]
#[doc = ""]
#[doc = " @param stream memory stream"]
pub fn grk_stream_get_write_mem_stream_length(stream: *mut grk_stream) -> usize;
}
extern "C" {
#[doc = " Create mapped file stream"]
#[doc = ""]
#[doc = " @param fname\t\t\tfile name"]
#[doc = " @param read_stream \ttrue if this is a read stream, otherwise false"]
pub fn grk_stream_create_mapped_file_stream(
fname: *const ::std::os::raw::c_char,
read_stream: bool,
) -> *mut grk_stream;
}
extern "C" {
#[doc = " Create J2K/JP2 decompression structure"]
#[doc = ""]
#[doc = " @param format \t\tJPEG 2000 format"]
#[doc = " @param\tstream\tJPEG 2000 stream."]
#[doc = ""]
#[doc = " @return a handle to a decompressor if successful, otherwise nullptr"]
pub fn grk_decompress_create(
format: GRK_CODEC_FORMAT,
stream: *mut grk_stream,
) -> *mut grk_codec;
}
extern "C" {
#[doc = " Initialize decompress parameters with default values"]
#[doc = ""]
#[doc = " @param parameters decompression parameters"]
pub fn grk_decompress_set_default_params(parameters: *mut grk_dparameters);
}
extern "C" {
#[doc = " Set up the decompressor with decompress parameters"]
#[doc = ""]
#[doc = " @param codec \t\tdecompressor handler"]
#[doc = " @param parameters \tdecompression parameters"]
#[doc = ""]
#[doc = " @return true\t\t\tif the decompressor is correctly set"]
pub fn grk_decompress_init(codec: *mut grk_codec, parameters: *mut grk_dparameters) -> bool;
}
extern "C" {
#[doc = " Decompress JPEG 2000 header"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\t\tJPEG 2000 code stream to read."]
#[doc = " @param\theader_info\t\t\tinformation read from JPEG 2000 header."]
#[doc = " @param\timage\t\t\t\tthe image structure initialized with the characteristics"]
#[doc = "\t\t\t\t\t\t\t\tof encoded image."]
#[doc = " @return true\t\t\t\t\tif the main header of the code stream and the JP2 header"]
#[doc = " \t\t\t\t\t\t\t \tis correctly read."]
pub fn grk_decompress_read_header(
codec: *mut grk_codec,
header_info: *mut grk_header_info,
) -> bool;
}
extern "C" {
#[doc = " Get decompressed tile image"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\t\tJPEG 2000 code stream to read."]
#[doc = " @param\ttileIndex\t\t\ttile index"]
#[doc = ""]
#[doc = " @return pointer to decompressed image"]
pub fn grk_decompress_get_tile_image(codec: *mut grk_codec, tileIndex: u16) -> *mut grk_image;
}
extern "C" {
#[doc = " Get decompressed composite image"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\t\tJPEG 2000 code stream to read."]
#[doc = ""]
#[doc = " @return pointer to decompressed image"]
pub fn grk_decompress_get_composited_image(codec: *mut grk_codec) -> *mut grk_image;
}
extern "C" {
#[doc = " Set the given area to be decompressed. This function should be called"]
#[doc = " right after grk_decompress_read_header is called, and before any tile header is read."]
#[doc = ""]
#[doc = " @param\tcodec\t\t\tJPEG 2000 code stream."]
#[doc = " @param\tstart_x\t\t left position of the rectangle to decompress (in image coordinates)."]
#[doc = " @param\tend_x\t\t\tthe right position of the rectangle to decompress (in image"]
#[doc = " coordinates)."]
#[doc = " @param\tstart_y\t\t up position of the rectangle to decompress (in image coordinates)."]
#[doc = " @param\tend_y\t\t\tbottom position of the rectangle to decompress (in image coordinates)."]
#[doc = ""]
#[doc = " @return\ttrue\t\t\tif the area could be set."]
pub fn grk_decompress_set_window(
codec: *mut grk_codec,
start_x: u32,
start_y: u32,
end_x: u32,
end_y: u32,
) -> bool;
}
extern "C" {
#[doc = " Decompress image from a JPEG 2000 code stream"]
#[doc = ""]
#[doc = " @param p_decompressor \tdecompressor handle"]
#[doc = " @param tile\t\t\t \ttile struct from plugin"]
#[doc = " @return \t\t\t\t\ttrue if successful, otherwise false"]
pub fn grk_decompress(p_decompressor: *mut grk_codec, tile: *mut grk_plugin_tile) -> bool;
}
extern "C" {
#[doc = " Decompress a specific tile"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\tJPEG 2000 code stream"]
#[doc = " @param\ttileIndex\t\tindex of the tile to be decompressed"]
#[doc = ""]
#[doc = " @return\t\t\t\t\ttrue if successful, otherwise false"]
pub fn grk_decompress_tile(codec: *mut grk_codec, tileIndex: u16) -> bool;
}
extern "C" {
#[doc = " End decompression"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\tJPEG 2000 code stream"]
pub fn grk_decompress_end(codec: *mut grk_codec) -> bool;
}
extern "C" {
#[doc = " Creates a J2K/JP2 compression structure"]
#[doc = " @param \tformat \t\tCoder to select"]
#[doc = " @param\tstream\tthe JPEG 2000 stream."]
#[doc = " @return \t\t\t\tReturns a handle to a compressor if successful,"]
#[doc = " \t\t\t\t\t\treturns nullptr otherwise"]
pub fn grk_compress_create(format: GRK_CODEC_FORMAT, stream: *mut grk_stream)
-> *mut grk_codec;
}
extern "C" {
#[doc = "Set compressing parameters to default values, that means :"]
#[doc = ""]
#[doc = "Lossless"]
#[doc = "Single tile"]
#[doc = "Size of precinct : 2^15 x 2^15 (i.e. single precinct)"]
#[doc = "Size of code block : 64 x 64"]
#[doc = "Number of resolutions: 6"]
#[doc = "No SOP marker in the code stream"]
#[doc = "No EPH marker in the code stream"]
#[doc = "No sub-sampling in x or y direction"]
#[doc = "No mode switch activated"]
#[doc = "Progression order: LRCP"]
#[doc = "No index file"]
#[doc = "No ROI upshifted"]
#[doc = "Image origin lies at (0,0)"]
#[doc = "Tile origin lies at (0,0)"]
#[doc = "Reversible DWT 5-3 transform"]
#[doc = ""]
#[doc = "@param parameters Compression parameters"]
pub fn grk_compress_set_default_params(parameters: *mut grk_cparameters);
}
extern "C" {
#[doc = " Set up the compressor parameters using the current image and user parameters."]
#[doc = ""]
#[doc = " @param codec \t\tJPEG 2000 code stream"]
#[doc = " @param parameters \tcompression parameters"]
#[doc = " @param image \t\tinput image"]
pub fn grk_compress_init(
codec: *mut grk_codec,
parameters: *mut grk_cparameters,
image: *mut grk_image,
) -> bool;
}
extern "C" {
#[doc = " Start compressing current image."]
#[doc = ""]
#[doc = " @param codec \t\tCompressor handle"]
#[doc = ""]
pub fn grk_compress_start(codec: *mut grk_codec) -> bool;
}
extern "C" {
#[doc = " Encode an image into a JPEG 2000 code stream"]
#[doc = " @param codec \t\tcompressor handle"]
#[doc = ""]
#[doc = " @return \t\t\t\tReturns true if successful, returns false otherwise"]
pub fn grk_compress(codec: *mut grk_codec) -> bool;
}
extern "C" {
#[doc = " Compress uncompressed data stored in a buffer."]
#[doc = " This method should be called right after grk_compress_start,"]
#[doc = " and before grk_end_compress."]
#[doc = ""]
#[doc = " @param\tcodec\t\t JPEG 2000 code stream"]
#[doc = " @param\ttileIndex\t\tthe index of the tile to write. At the moment,"]
#[doc = " \t\t\t\t\t\t\tthe tiles must be written from 0 to n-1 in sequence."]
#[doc = " @param\tdata\t\t\tpointer to the data to write. Data is arranged in planar"]
#[doc = " \t\t\t\t\t\tsequence, data_comp0, data_comp1 etc,"]
#[doc = " \t\t\t\t\t\tThe data should NOT BE INTERLEAVED."]
#[doc = " @param\tdata_size\t\tthis value is used to ensure the data"]
#[doc = " \t\t\t\t\t\t\tbeing written is correct. The size must be"]
#[doc = " \t\t\t\t\t\t\tequal to the sum for each component of"]
#[doc = " tile_width * tile_height * component_size."]
#[doc = " component_size can be 1 or 2 bytes, depending on"]
#[doc = " the precision of the given component."]
#[doc = ""]
#[doc = " @return\ttrue if the data could be written."]
pub fn grk_compress_tile(
codec: *mut grk_codec,
tileIndex: u16,
data: *mut u8,
data_size: u64,
) -> bool;
}
extern "C" {
#[doc = " Encode an image into a JPEG 2000 code stream using plugin"]
#[doc = " @param codec \t\tcompressor handle"]
#[doc = " @param tile\t\t\tplugin tile"]
#[doc = ""]
#[doc = " @return \t\t\t\tReturns true if successful, returns false otherwise"]
pub fn grk_compress_with_plugin(codec: *mut grk_codec, tile: *mut grk_plugin_tile) -> bool;
}
extern "C" {
#[doc = " End to compress the current image."]
#[doc = " @param codec \t\tCompressor handle"]
pub fn grk_compress_end(codec: *mut grk_codec) -> bool;
}
extern "C" {
#[doc = " Dump codec information to file"]
#[doc = ""]
#[doc = " @param\tcodec\t\t\tJPEG 2000 code stream."]
#[doc = " @param\tinfo_flag\t\ttype of information dump."]
#[doc = " @param\toutput_stream\toutput stream where dump the information get from the codec."]
#[doc = ""]
pub fn grk_dump_codec(codec: *mut grk_codec, info_flag: u32, output_stream: *mut FILE);
}
extern "C" {
#[doc = " Set the MCT matrix to use."]
#[doc = ""]
#[doc = " @param\tparameters\t\tthe parameters to change."]
#[doc = " @param\tpEncodingMatrix\tthe compressing matrix."]
#[doc = " @param\tp_dc_shift\t\tthe dc shift coefficients to use."]
#[doc = " @param\tpNbComp\t\t\tthe number of components of the image."]
#[doc = ""]
#[doc = " @return\ttrue if the parameters could be set."]
pub fn grk_set_MCT(
parameters: *mut grk_cparameters,
pEncodingMatrix: *mut f32,
p_dc_shift: *mut i32,
pNbComp: u32,
) -> bool;
}
#[doc = "Plugin Interface"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_load_info {
pub pluginPath: *const ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout__grk_plugin_load_info() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_load_info>(),
8usize,
concat!("Size of: ", stringify!(_grk_plugin_load_info))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_load_info>(),
8usize,
concat!("Alignment of ", stringify!(_grk_plugin_load_info))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_load_info>())).pluginPath as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_load_info),
"::",
stringify!(pluginPath)
)
);
}
#[doc = "Plugin Interface"]
pub type grk_plugin_load_info = _grk_plugin_load_info;
extern "C" {
#[doc = " Load plugin"]
#[doc = ""]
#[doc = " @param info\t\tplugin loading info"]
pub fn grk_plugin_load(info: grk_plugin_load_info) -> bool;
}
extern "C" {
#[doc = " Release plugin resources"]
pub fn grk_plugin_cleanup();
}
extern "C" {
#[doc = " Get debug state of plugin"]
pub fn grk_plugin_get_debug_state() -> u32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _grk_plugin_init_info {
pub deviceId: i32,
pub verbose: bool,
}
#[test]
fn bindgen_test_layout__grk_plugin_init_info() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_init_info>(),
8usize,
concat!("Size of: ", stringify!(_grk_plugin_init_info))
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_init_info>(),
4usize,
concat!("Alignment of ", stringify!(_grk_plugin_init_info))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_init_info>())).deviceId as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_init_info),
"::",
stringify!(deviceId)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_grk_plugin_init_info>())).verbose as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_init_info),
"::",
stringify!(verbose)
)
);
}
pub type grk_plugin_init_info = _grk_plugin_init_info;
extern "C" {
#[doc = " Initialize plugin"]
pub fn grk_plugin_init(initInfo: grk_plugin_init_info) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct grk_plugin_compress_user_callback_info {
pub input_file_name: *const ::std::os::raw::c_char,
pub outputFileNameIsRelative: bool,
pub output_file_name: *const ::std::os::raw::c_char,
pub compressor_parameters: *mut grk_cparameters,
pub image: *mut grk_image,
pub tile: *mut grk_plugin_tile,
pub compressBuffer: *mut u8,
pub compressBufferLen: usize,
pub error_code: ::std::os::raw::c_uint,
pub transferExifTags: bool,
}
#[test]
fn bindgen_test_layout_grk_plugin_compress_user_callback_info() {
assert_eq!(
::std::mem::size_of::<grk_plugin_compress_user_callback_info>(),
72usize,
concat!(
"Size of: ",
stringify!(grk_plugin_compress_user_callback_info)
)
);
assert_eq!(
::std::mem::align_of::<grk_plugin_compress_user_callback_info>(),
8usize,
concat!(
"Alignment of ",
stringify!(grk_plugin_compress_user_callback_info)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).input_file_name
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(input_file_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>()))
.outputFileNameIsRelative as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(outputFileNameIsRelative)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).output_file_name
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(output_file_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).compressor_parameters
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(compressor_parameters)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).image as *const _
as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(image)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).tile as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(tile)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).compressBuffer
as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(compressBuffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).compressBufferLen
as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(compressBufferLen)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).error_code
as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(error_code)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<grk_plugin_compress_user_callback_info>())).transferExifTags
as *const _ as usize
},
68usize,
concat!(
"Offset of field: ",
stringify!(grk_plugin_compress_user_callback_info),
"::",
stringify!(transferExifTags)
)
);
}
pub type GRK_PLUGIN_COMPRESS_USER_CALLBACK = ::std::option::Option<
unsafe extern "C" fn(info: *mut grk_plugin_compress_user_callback_info) -> bool,
>;
extern "C" {
#[doc = " Compress with plugin"]
#[doc = ""]
#[doc = " @param compress_parameters \tcompress parameters"]
#[doc = " @param callback\t\t\t\tcallback"]
pub fn grk_plugin_compress(
compress_parameters: *mut grk_cparameters,
callback: GRK_PLUGIN_COMPRESS_USER_CALLBACK,
) -> i32;
}
extern "C" {
#[doc = " Batch compress with plugin"]
#[doc = ""]
#[doc = " @param input_dir\t\t\t\tdirectory holding input images"]
#[doc = " @param output_dir\t\t\tdirectory holding compressed output images"]
#[doc = " @param compress_parameters \tcompress parameters"]
#[doc = " @param callback\t\t\t\tcallback"]
#[doc = ""]
#[doc = " @return 0 if successful"]
#[doc = ""]
pub fn grk_plugin_batch_compress(
input_dir: *const ::std::os::raw::c_char,
output_dir: *const ::std::os::raw::c_char,
compress_parameters: *mut grk_cparameters,
callback: GRK_PLUGIN_COMPRESS_USER_CALLBACK,
) -> i32;
}
extern "C" {
#[doc = " Check if batch job is complete"]
pub fn grk_plugin_is_batch_complete() -> bool;
}
extern "C" {
#[doc = " Stop batch compress"]
pub fn grk_plugin_stop_batch_compress();
}
pub type GROK_INIT_DECOMPRESSORS = ::std::option::Option<
unsafe extern "C" fn(
header_info: *mut grk_header_info,
image: *mut grk_image,
) -> ::std::os::raw::c_int,
>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct _grk_plugin_decompress_callback_info {
pub deviceId: usize,
pub init_decompressors_func: GROK_INIT_DECOMPRESSORS,
pub input_file_name: *const ::std::os::raw::c_char,
pub output_file_name: *const ::std::os::raw::c_char,
pub decod_format: GRK_SUPPORTED_FILE_FMT,
pub cod_format: GRK_SUPPORTED_FILE_FMT,
pub stream: *mut grk_stream,
pub codec: *mut grk_codec,
pub header_info: grk_header_info,
pub decompressor_parameters: *mut grk_decompress_parameters,
pub image: *mut grk_image,
pub plugin_owns_image: bool,
pub tile: *mut grk_plugin_tile,
pub error_code: ::std::os::raw::c_uint,
pub decompress_flags: u32,
pub full_image_x0: u32,
pub full_image_y0: u32,
pub user_data: *mut ::std::os::raw::c_void,
}
#[test]
fn bindgen_test_layout__grk_plugin_decompress_callback_info() {
assert_eq!(
::std::mem::size_of::<_grk_plugin_decompress_callback_info>(),
11472usize,
concat!(
"Size of: ",
stringify!(_grk_plugin_decompress_callback_info)
)
);
assert_eq!(
::std::mem::align_of::<_grk_plugin_decompress_callback_info>(),
8usize,
concat!(
"Alignment of ",
stringify!(_grk_plugin_decompress_callback_info)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).deviceId as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(deviceId)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).init_decompressors_func
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(init_decompressors_func)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).input_file_name
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(input_file_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).output_file_name
as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(output_file_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).decod_format
as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(decod_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).cod_format as *const _
as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(cod_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).stream as *const _
as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).codec as *const _
as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(codec)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).header_info as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(header_info)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).decompressor_parameters
as *const _ as usize
},
11416usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(decompressor_parameters)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).image as *const _
as usize
},
11424usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(image)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).plugin_owns_image
as *const _ as usize
},
11432usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(plugin_owns_image)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).tile as *const _
as usize
},
11440usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(tile)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).error_code as *const _
as usize
},
11448usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(error_code)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).decompress_flags
as *const _ as usize
},
11452usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(decompress_flags)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).full_image_x0
as *const _ as usize
},
11456usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(full_image_x0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).full_image_y0
as *const _ as usize
},
11460usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(full_image_y0)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<_grk_plugin_decompress_callback_info>())).user_data as *const _
as usize
},
11464usize,
concat!(
"Offset of field: ",
stringify!(_grk_plugin_decompress_callback_info),
"::",
stringify!(user_data)
)
);
}
pub type grk_plugin_decompress_callback_info = _grk_plugin_decompress_callback_info;
pub type grk_plugin_decompress_callback = ::std::option::Option<
unsafe extern "C" fn(info: *mut grk_plugin_decompress_callback_info) -> i32,
>;
extern "C" {
#[doc = " Decompress with plugin"]
#[doc = ""]
#[doc = " @param decompress_parameters decompress parameters"]
#[doc = " @param callback \t\t\t callback"]
pub fn grk_plugin_decompress(
decompress_parameters: *mut grk_decompress_parameters,
callback: grk_plugin_decompress_callback,
) -> i32;
}
extern "C" {
#[doc = " Initialize batch decompress"]
#[doc = ""]
#[doc = " @param input_dir input directory holding compressed images"]
#[doc = " @param output_dir output directory holding decompressed images"]
#[doc = " @param decompress_parameters decompress parameters"]
#[doc = " @param callback \t\t\t callback"]
#[doc = ""]
#[doc = " @return 0 if successful"]
pub fn grk_plugin_init_batch_decompress(
input_dir: *const ::std::os::raw::c_char,
output_dir: *const ::std::os::raw::c_char,
decompress_parameters: *mut grk_decompress_parameters,
callback: grk_plugin_decompress_callback,
) -> i32;
}
extern "C" {
#[doc = " Batch decompress"]
pub fn grk_plugin_batch_decompress() -> i32;
}
extern "C" {
#[doc = " Stop batch decompress"]
pub fn grk_plugin_stop_batch_decompress();
}