Skip to main content

video_interop/
sync_file.rs

1use std::os::fd::OwnedFd;
2
3use crate::{DuplicateError, duplicate_fd_cloexec};
4
5#[derive(Clone, Debug)]
6#[cfg_attr(feature = "rustler", derive(rustler::NifStruct))]
7#[cfg_attr(feature = "rustler", module = "VideoInterop.SyncFile")]
8pub struct SyncFile {
9    pub acquire_fence_fd: i32,
10}
11
12#[derive(Clone, Debug)]
13pub enum AcquireSync {
14    Implicit,
15    SyncFile(SyncFile),
16}
17
18#[derive(Debug)]
19pub enum OwnedAcquireSync {
20    Implicit,
21    SyncFile(OwnedFd),
22}
23
24impl SyncFile {
25    pub fn duplicate_cloexec(&self) -> Result<OwnedFd, DuplicateError> {
26        if self.acquire_fence_fd < 0 {
27            return Err(DuplicateError::NegativeAcquireFence(self.acquire_fence_fd));
28        }
29
30        duplicate_fd_cloexec(self.acquire_fence_fd).map_err(|source| {
31            DuplicateError::DuplicateAcquireFence {
32                fd: self.acquire_fence_fd,
33                source,
34            }
35        })
36    }
37}
38
39impl AcquireSync {
40    pub fn duplicate_cloexec(&self) -> Result<OwnedAcquireSync, DuplicateError> {
41        match self {
42            Self::Implicit => Ok(OwnedAcquireSync::Implicit),
43            Self::SyncFile(sync_file) => sync_file
44                .duplicate_cloexec()
45                .map(OwnedAcquireSync::SyncFile),
46        }
47    }
48}
49
50#[cfg(feature = "rustler")]
51mod rustler_impl {
52    use rustler::{Decoder, Encoder, Env, Error, NifResult, Term};
53
54    use super::{AcquireSync, SyncFile};
55
56    mod atoms {
57        rustler::atoms! {
58            implicit
59        }
60    }
61
62    impl<'a> Decoder<'a> for AcquireSync {
63        fn decode(term: Term<'a>) -> NifResult<Self> {
64            if let Ok(atom) = term.decode::<rustler::Atom>() {
65                return if atom == atoms::implicit() {
66                    Ok(Self::Implicit)
67                } else {
68                    Err(Error::BadArg)
69                };
70            }
71
72            term.decode::<SyncFile>().map(Self::SyncFile)
73        }
74    }
75
76    impl Encoder for AcquireSync {
77        fn encode<'a>(&self, env: Env<'a>) -> Term<'a> {
78            match self {
79                Self::Implicit => atoms::implicit().encode(env),
80                Self::SyncFile(sync_file) => sync_file.encode(env),
81            }
82        }
83    }
84}