/* automatically generated by rust-bindgen 0.58.1 */

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();
}