glycin-utils 5.0.0-alpha

Sandboxed image decoding
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
101
102
103
104
105
106

#[cfg(feature = "external")]
use zbus::zvariant::{DeserializeDict, SerializeDict, Type, as_value};

use crate::{ByteData, FungibleMemory, MemoryAllocationError, api};

#[derive(Debug)]
#[cfg_attr(
    feature = "external",
    derive(Type, serde::Serialize, serde::Deserialize)
)]
#[cfg_attr(feature = "external", zvariant(signature = "dict"))]
#[cfg_attr(
    feature = "external",
    serde(bound(
        serialize = "B: ByteData + serde::Serialize + zbus::zvariant::Type + 'static",
        deserialize = "B: ByteData + serde::de::DeserializeOwned + zbus::zvariant::Type + 'static"
    ))
)]
#[non_exhaustive]
pub struct NewImage<B: ByteData> {
    #[cfg_attr(feature = "external", serde(with = "as_value"))]
    pub image_info: api::ImageDetails<B>,
    #[cfg_attr(feature = "external", serde(with = "as_value"))]
    pub frames: Vec<api::Frame<B>>,
}

impl<B: ByteData> NewImage<B> {
    pub fn new(image_info: api::ImageDetails<B>, frames: Vec<api::Frame<B>>) -> Self {
        Self { image_info, frames }
    }

    pub fn into_other<O: ByteData>(self) -> Result<NewImage<O>, MemoryAllocationError> {
        Ok(NewImage {
            image_info: self.image_info.into_other()?,
            frames: self
                .frames
                .into_iter()
                .map(|x| x.into_other::<O>())
                .collect::<Result<_, _>>()?,
        })
    }

    pub async fn initial_seal(&mut self) -> Result<(), MemoryAllocationError> {
        self.image_info.initial_seal().await?;
        for frame in &mut self.frames {
            frame.initial_seal().await?;
        }
        Ok(())
    }

    pub async fn final_seal(&mut self) -> Result<(), MemoryAllocationError> {
        self.image_info.final_seal().await?;
        for frame in &mut self.frames {
            frame.final_seal().await?;
        }
        Ok(())
    }
}

#[derive(Debug, Default)]
#[cfg_attr(feature = "external", derive(DeserializeDict, SerializeDict, Type))]
#[cfg_attr(feature = "external", zvariant(signature = "dict"))]
#[non_exhaustive]
pub struct EncodingOptions {
    pub quality: Option<u8>,
    pub compression: Option<u8>,
}

#[derive(Debug)]
#[cfg_attr(
    feature = "external",
    derive(Type, serde::Serialize, serde::Deserialize)
)]
#[cfg_attr(feature = "external", zvariant(signature = "dict"))]
#[cfg_attr(
    feature = "external",
    serde(bound(
        serialize = "B: ByteData + serde::Serialize + zbus::zvariant::Type + 'static",
        deserialize = "B: ByteData + serde::de::DeserializeOwned + zbus::zvariant::Type + 'static"
    ))
)]
#[non_exhaustive]
pub struct EncodedImage<B: ByteData> {
    #[cfg_attr(feature = "external", serde(with = "as_value"))]
    pub data: B,
}

impl<B: ByteData> EncodedImage<B> {
    pub fn new(data: B) -> Self {
        Self { data }
    }

    pub async fn inital_seal(&mut self) -> Result<(), MemoryAllocationError> {
        self.data.initial_seal().await
    }

    pub async fn final_seal(&mut self) -> Result<(), MemoryAllocationError> {
        self.data.final_seal().await
    }

    pub fn into_fungible(self) -> EncodedImage<FungibleMemory> {
        EncodedImage {
            data: self.data.into_fungible(),
        }
    }
}