libde265 0.2.0

Low-level bindings for libdeH265.
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
99
100

use std::ffi::CStr;

use libde265_sys::de265_error;

#[derive(Clone, Copy, Debug, thiserror::Error)]
pub enum Error {
    #[error("no such file")]
    NoSuchFile,

    #[error("checksum mismatch")]
    ChecksumMismatch,

    #[error("ctb outside image area")]
    CtbOutsideImageArea,

    #[error("out of memory")]
    OutOfMemory,

    #[error("coded parameter out of range")]
    CodedParameterOutOfRange,

    #[error("image buffer full")]
    ImageBufferFull,

    #[error("cannot start threadpool")]
    CannotStartThreadpool,

    #[error("Library Initialization Failed")]
    LibraryInitializationFailed,

    #[error("coefficient out of image bounds")]
    CoefficientOutOfImageBounds,

    #[error("library not initialized")]
    LibraryNotInitialized,

    #[error("waiting for input data")]
    WaitingForInputData,

    #[error("cannot process sei")]
    CannotProcessSei,

    #[error("parameter parsing")]
    ParameterParsing,

    #[error("noinitial slice header")]
    NoInitialSliceHeader,

    #[error("premature end of slice")]
    PrematureEndOfSlice,

    #[error("unspecified decoding error")]
    UnspecifiedDecodingError,

    #[error("not yet implemented")]
    NotImplementedYet,

    #[error("unknown error {0}")]
    UnknownError(u32),
}

impl Error {
    pub fn from_res(kind: de265_error::Type) -> Result<(), Self> {
        match kind {
            de265_error::DE265_OK => Ok(()),
            de265_error::DE265_ERROR_NO_SUCH_FILE => Err(Error::NoSuchFile),
            de265_error::DE265_ERROR_COEFFICIENT_OUT_OF_IMAGE_BOUNDS => {
                Err(Error::CoefficientOutOfImageBounds)
            }
            de265_error::DE265_ERROR_CHECKSUM_MISMATCH => Err(Error::ChecksumMismatch),
            de265_error::DE265_ERROR_CTB_OUTSIDE_IMAGE_AREA => Err(Error::CtbOutsideImageArea),
            de265_error::DE265_ERROR_OUT_OF_MEMORY => Err(Error::OutOfMemory),
            de265_error::DE265_ERROR_CODED_PARAMETER_OUT_OF_RANGE => {
                Err(Error::CodedParameterOutOfRange)
            }
            de265_error::DE265_ERROR_IMAGE_BUFFER_FULL => Err(Error::ImageBufferFull),
            de265_error::DE265_ERROR_CANNOT_START_THREADPOOL => Err(Error::CannotStartThreadpool),
            de265_error::DE265_ERROR_LIBRARY_INITIALIZATION_FAILED => {
                Err(Error::LibraryInitializationFailed)
            }
            de265_error::DE265_ERROR_LIBRARY_NOT_INITIALIZED => Err(Error::LibraryNotInitialized),
            de265_error::DE265_ERROR_WAITING_FOR_INPUT_DATA => Err(Error::WaitingForInputData),
            de265_error::DE265_ERROR_CANNOT_PROCESS_SEI => Err(Error::CannotProcessSei),
            de265_error::DE265_ERROR_PARAMETER_PARSING => Err(Error::ParameterParsing),
            de265_error::DE265_ERROR_NO_INITIAL_SLICE_HEADER => Err(Error::NoInitialSliceHeader),
            de265_error::DE265_ERROR_PREMATURE_END_OF_SLICE => Err(Error::PrematureEndOfSlice),
            de265_error::DE265_ERROR_UNSPECIFIED_DECODING_ERROR => {
                Err(Error::UnspecifiedDecodingError)
            }
            de265_error::DE265_ERROR_NOT_IMPLEMENTED_YET => Err(Error::NotImplementedYet),

            warning @ 1000.. => {
                let msg = unsafe { CStr::from_ptr(libde265_sys::de265_get_error_text(warning)) };
                log::warn!("{}", msg.to_string_lossy());
                Ok(())
            }
            code => Err(Self::UnknownError(code)),
        }
    }
}