j2k-cuda-runtime 0.7.5

CUDA codec engine and Driver API runtime for j2k device adapters
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

// SPDX-License-Identifier: MIT OR Apache-2.0

use crate::{
    error::{select_resource_release_error, CudaError},
    execution::CudaExecutionStats,
};

use super::CudaHtj2kStatus;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub(super) struct CudaHtj2kStatusSpan {
    pub(super) start: usize,
    pub(super) count: usize,
    pub(super) kernel: &'static str,
}

pub(super) fn first_status_error(
    statuses: &[CudaHtj2kStatus],
    kernel: &'static str,
) -> Option<CudaError> {
    statuses
        .iter()
        .copied()
        .enumerate()
        .find(|(_, status)| !status.is_ok())
        .map(|(job_index, status)| CudaError::KernelJobStatus {
            kernel,
            job_index,
            code: status.code,
            detail: status.detail,
        })
}

pub(super) fn first_group_status_error(
    statuses: &[CudaHtj2kStatus],
    spans: &[CudaHtj2kStatusSpan],
) -> Option<CudaError> {
    for span in spans {
        let end = span.start.checked_add(span.count)?;
        let span_statuses = statuses.get(span.start..end)?;
        if let Some((local_index, status)) = span_statuses
            .iter()
            .copied()
            .enumerate()
            .find(|(_, status)| !status.is_ok())
        {
            return Some(CudaError::KernelJobStatus {
                kernel: span.kernel,
                job_index: span.start.saturating_add(local_index),
                code: status.code,
                detail: status.detail,
            });
        }
    }
    None
}

pub(super) fn select_status_release_result(
    execution: CudaExecutionStats,
    status_error: Option<CudaError>,
    release_result: Result<(), CudaError>,
) -> Result<CudaExecutionStats, CudaError> {
    match (status_error, release_result) {
        (Some(primary_error), Err(release_error)) => {
            Err(select_resource_release_error(primary_error, release_error))
        }
        (Some(error), Ok(())) | (None, Err(error)) => Err(error),
        (None, Ok(())) => Ok(execution),
    }
}

#[cfg(test)]
mod tests;