nvtiff-sys 0.3.0

Rust bindings to nvTIFF via bindgen
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#![doc = include_str!("../README.md")]
#![allow(non_upper_case_globals)]
#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

pub mod nvtiff;
pub mod result;
pub use nvtiff::*;
pub use result::{NvTiffResult, NvTiffResultCheck};

#[cfg(test)]
mod tests {
    use crate::{
        nvtiffCompression, nvtiffImageInfo, nvtiffPhotometricInt, nvtiffPlanarConfig,
        nvtiffSampleFormat, nvtiffStatus, nvtiffStream, nvtiffStreamCreate,
        nvtiffStreamGetImageInfo, nvtiffStreamGetNumImages, nvtiffStreamParseFromFile,
    };

    #[test]
    fn test_nvtiff_get_metadata_info() {
        // nvTIFF decoding!!
        // https://docs.nvidia.com/cuda/nvtiff/quickstartguide.html#nvtiff-decode

        // Step 0: Create bitstream
        // https://stackoverflow.com/questions/43350167/how-do-i-initialize-an-opaque-c-struct-when-using-rust-ffi
        let mut stream = std::mem::MaybeUninit::uninit();
        let mut tiff_stream: *mut nvtiffStream = stream.as_mut_ptr();

        let status_create: nvtiffStatus::Type = unsafe { nvtiffStreamCreate(&raw mut tiff_stream) };
        dbg!(status_create); // should be 0=SUCCESS
        assert_eq!(status_create, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

        // Step 1: Parse the TIFF file from disk
        let tiff_cstr = std::ffi::CString::new("images/bali_notiles.tif").unwrap();
        let tiff_path: *const std::os::raw::c_char = tiff_cstr.as_ptr();

        let status_parse: u32 = unsafe { nvtiffStreamParseFromFile(tiff_path, tiff_stream) };
        dbg!(status_parse); // should be 0=SUCCESS
        assert_eq!(status_parse, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

        // Step 2: Extract file-level metadata information from the TIFF stream
        let mut num_images: u32 = 0;

        let status_numimages: u32 =
            unsafe { nvtiffStreamGetNumImages(tiff_stream, &raw mut num_images) };
        assert_eq!(status_numimages, nvtiffStatus::NVTIFF_STATUS_SUCCESS);
        dbg!(status_numimages);
        assert_eq!(num_images, 1);

        // Step 3: Extract image-level metadata information from the TIFF stream
        let mut image_info = nvtiffImageInfo::default();

        let status_imageinfo: u32 =
            unsafe { nvtiffStreamGetImageInfo(tiff_stream, 0, &raw mut image_info) };
        assert_eq!(status_imageinfo, nvtiffStatus::NVTIFF_STATUS_SUCCESS);
        dbg!(image_info);
        assert_eq!(
            image_info,
            nvtiffImageInfo {
                image_type: 0, // nvtiffImageType::NVTIFF_IMAGETYPE_?,
                image_width: 725,
                image_height: 489,
                compression: nvtiffCompression::NVTIFF_COMPRESSION_LZW, // 5
                photometric_int: nvtiffPhotometricInt::NVTIFF_PHOTOMETRIC_RGB, // 2
                planar_config: nvtiffPlanarConfig::NVTIFF_PLANARCONFIG_CONTIG, // 1
                samples_per_pixel: 3,
                bits_per_pixel: 24,
                bits_per_sample: [8, 8, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                sample_format: [
                    nvtiffSampleFormat::NVTIFF_SAMPLEFORMAT_UINT, // 1
                    nvtiffSampleFormat::NVTIFF_SAMPLEFORMAT_UINT, // 1
                    nvtiffSampleFormat::NVTIFF_SAMPLEFORMAT_UINT, // 1
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0,
                    0
                ],
            }
        );
    }
}