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
91
92
93
94
95
96
97
98

/// Integration tests on the nvTIFF
/// [Decode API](https://docs.nvidia.com/cuda/nvtiff/userguide.html#decode-api-reference)
use std::sync::Arc;

use cudarc::driver::{CudaContext, CudaSlice, CudaStream, DevicePtrMut, DriverError};
use nvtiff_sys::{
    nvtiffDecodeCheckSupported, nvtiffDecodeImage, nvtiffDecodeParams, nvtiffDecodeParamsCreate,
    nvtiffDecoder, nvtiffDecoderCreateSimple, nvtiffStatus, nvtiffStream, nvtiffStreamCreate,
    nvtiffStreamParseFromFile,
};

#[test]
fn decode_image() -> Result<(), DriverError> {
    // Step 1: Create stream pointers/handles on host (CPU) and device (GPU)

    // Step 1a: Init TIFF stream on host (CPU)
    let mut host_stream = std::mem::MaybeUninit::uninit();
    let mut tiff_stream: *mut nvtiffStream = host_stream.as_mut_ptr();

    let status_cpustream: nvtiffStatus::Type = unsafe { nvtiffStreamCreate(&raw mut tiff_stream) };
    assert_eq!(status_cpustream, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 1b: Init CUDA stream on device (GPU)
    let ctx: Arc<CudaContext> = cudarc::driver::CudaContext::new(0)?; // Set on GPU:0
    let stream: Arc<CudaStream> = ctx.default_stream();
    let cuda_stream: *mut nvtiff_sys::CUstream_st = stream.cu_stream().cast::<_>();

    // Step 1c: Init decoder handle
    let mut decoder_handle = std::mem::MaybeUninit::uninit();
    let mut nvtiff_decoder: *mut nvtiffDecoder = decoder_handle.as_mut_ptr();

    let status_decoder: u32 =
        unsafe { nvtiffDecoderCreateSimple(&raw mut nvtiff_decoder, cuda_stream) };
    dbg!(status_decoder);
    assert_eq!(status_decoder, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 2: Parse the TIFF file from disk
    let tiff_cstr = std::ffi::CString::new("images/float32.tif").expect("CString::new failed");
    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);
    assert_eq!(status_parse, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 3a: Create instance of decode parameters handle
    let mut params = std::mem::MaybeUninit::uninit();
    let mut decode_params: *mut nvtiffDecodeParams = params.as_mut_ptr();
    let status_param: u32 = unsafe { nvtiffDecodeParamsCreate(&raw mut decode_params) };
    dbg!(status_param);
    assert_eq!(status_param, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 3b: Check if image is supported first
    let status_check: u32 = unsafe {
        nvtiffDecodeCheckSupported(
            tiff_stream,
            nvtiff_decoder,
            decode_params,
            0, //image_id
        )
    };
    dbg!(status_check);
    assert_eq!(status_check, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 3c: Allocate memory on device, get pointer, do the TIFF decoding
    let image_size: usize = 3 * 2 * 4; // Width:3, Height:2, 4 bytes per f32 num
    let mut image_stream: CudaSlice<u8> = stream.alloc_zeros::<u8>(image_size)?;
    let image_ptr: u64 = image_stream.device_ptr_mut(&stream).0;
    let image_out_d = image_ptr as *mut std::ffi::c_void;
    let status_decode: u32 = unsafe {
        nvtiffDecodeImage(
            tiff_stream,
            nvtiff_decoder,
            decode_params,
            0, // image_id
            image_out_d,
            cuda_stream,
        )
    };
    dbg!(status_decode); // 2: NVTIFF_STATUS_INVALID_PARAMETER; 8: NVTIFF_STATUS_INTERNAL_ERROR
    assert_eq!(status_decode, nvtiffStatus::NVTIFF_STATUS_SUCCESS);

    // Step 2c: Transfer decoded bytes from device to host, and check results
    let mut image_out_h: Vec<u8> = vec![0; image_size];
    stream.memcpy_dtoh(&image_stream, &mut image_out_h)?;
    dbg!(image_out_h.clone());
    let float_array: Vec<f32> = image_out_h
        // https://stackoverflow.com/questions/77388769/convert-vecu8-to-vecfloat-in-rust
        // .array_chunks::<4>()
        // .copied()
        .chunks_exact(4)
        .map(TryInto::try_into)
        .map(Result::unwrap)
        .map(f32::from_le_bytes)
        .collect();
    assert_eq!(float_array, vec![1.41, 1.23, 0.78, 0.32, -0.23, -1.88]);

    Ok(())
}