vacc 0.1.2

Vacc video decoder: unified API over Vulkan, NVDEC, VAAPI and software backends with automatic fallback
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

//! Error types for the unified decoder.

use thiserror::Error;

use crate::backend::Backend;

/// A single backend's failure during [`VaccDecoder`](crate::VaccDecoder)
/// initialization.
#[derive(Debug, Clone)]
pub struct BackendFailure {
    pub backend: Backend,
    pub message: String,
}

impl std::fmt::Display for BackendFailure {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}: {}", self.backend, self.message)
    }
}

fn format_failures(failures: &[BackendFailure]) -> String {
    failures
        .iter()
        .map(|f| format!("  - {}", f))
        .collect::<Vec<_>>()
        .join("\n")
}

/// Errors from the unified decode/encode API.
#[derive(Debug, Error)]
pub enum UnifiedError {
    /// Every backend in the configured order failed to initialize.
    #[error("all configured backends failed to initialize:\n{details}", details = format_failures(failures))]
    AllBackendsFailed { failures: Vec<BackendFailure> },

    /// The configured backend list is empty.
    #[error("config contains no backends")]
    EmptyBackendOrder,

    /// The input codec could not be detected (needed by backends that have
    /// per-codec decoder types).
    #[error("could not detect the video codec of the input data")]
    CodecNotDetected,

    /// A backend does not support the requested operation or codec.
    #[error("{message}")]
    Unsupported { message: String },

    /// A runtime error from the active backend (decode, encode, flush, ...).
    #[error("backend error: {source}")]
    Backend { source: Box<dyn std::error::Error + Send + Sync> },

    /// Post-decode image processing (scale / Y'CbCr -> RGB) failed.
    #[error("image processing error: {message}")]
    ImageProcessing { message: String },
}

impl UnifiedError {
    /// The per-backend failures, if this is an [`AllBackendsFailed`](Self::AllBackendsFailed).
    pub fn failures(&self) -> Option<&[BackendFailure]> {
        match self {
            Self::AllBackendsFailed { failures } => Some(failures),
            _ => None,
        }
    }
}

pub type UnifiedResult<T> = std::result::Result<T, UnifiedError>;