video_interop/
sync_file.rs1use 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}