mediaframe 0.6.0

A common media-stream descriptor vocabulary (pixel-format, colour, and frame metadata for video — audio/subtitle to follow) for media processing pipelines.
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! One channel's entry in a custom-ordered layout — index, backend raw
//! id, and an optional label.

use smol_str::SmolStr;

/// One entry in a
/// [`ChannelLayoutDescription::custom_channels`](crate::audio::ChannelLayoutDescription::custom_channels)
/// list — the per-channel description for a
/// [`ChannelOrder::Custom`](crate::audio::ChannelOrder::Custom) layout.
///
/// Three fields, no relation between them: a position in the layout, the
/// backend's own id for the channel that sits there (FFmpeg's `AVChannel`
/// integer, say), and the human-readable label the backend prints for it
/// (`"FL"`, `"LFE"`) — empty when there is none.
///
/// With the `serde` feature the wire form is a map of the three
/// accessors' names — `{"index": 0, "raw_id": 1, "label": "FL"}`. The
/// record carries no invariant (every field has a public unchecked
/// setter), so the derive is the whole story: there is nothing a
/// hand-written `Deserialize` would have to re-check. `serde(default)`
/// keeps sparse / older-schema documents readable — a missing field
/// falls back to the all-zero [`Default`].
#[cfg_attr(
  feature = "serde",
  derive(serde::Serialize, serde::Deserialize),
  serde(default)
)]
#[cfg_attr(
  feature = "quickcheck",
  derive(::quickcheck_richderive::Arbitrary),
  quickcheck(arbitrary = "crate::quickcheck_helpers::composite::channel_spec")
)]
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ChannelSpec {
  index: u32,
  raw_id: u32,
  label: SmolStr,
}

impl Default for ChannelSpec {
  /// Delegates to [`ChannelSpec::new`] — channel `0`, raw id `0`, no
  /// label.
  #[cfg_attr(not(tarpaulin), inline(always))]
  fn default() -> Self {
    Self::new(0, 0)
  }
}

impl ChannelSpec {
  /// Constructs a `ChannelSpec` with the given channel index and
  /// backend-specific raw id. The label starts empty; fill it in with
  /// [`Self::with_label`].
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn new(index: u32, raw_id: u32) -> Self {
    Self {
      index,
      raw_id,
      label: SmolStr::new_inline(""),
    }
  }

  /// Index of this channel in the layout (0-based).
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn index(&self) -> u32 {
    self.index
  }

  /// Backend-specific channel id (e.g. FFmpeg's `AVChannel` integer).
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn raw_id(&self) -> u32 {
    self.raw_id
  }

  /// Human-readable label, or the empty string when unspecified.
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub fn label(&self) -> &str {
    self.label.as_str()
  }

  /// Sets the channel index — consuming builder.
  #[must_use]
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn with_index(mut self, v: u32) -> Self {
    self.index = v;
    self
  }

  /// Sets the raw id — consuming builder.
  #[must_use]
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn with_raw_id(mut self, v: u32) -> Self {
    self.raw_id = v;
    self
  }

  /// Sets the label — consuming builder.
  #[must_use]
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub fn with_label(mut self, v: impl Into<SmolStr>) -> Self {
    self.label = v.into();
    self
  }

  /// Sets the channel index in place.
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn set_index(&mut self, v: u32) -> &mut Self {
    self.index = v;
    self
  }

  /// Sets the raw id in place.
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub const fn set_raw_id(&mut self, v: u32) -> &mut Self {
    self.raw_id = v;
    self
  }

  /// Sets the label in place.
  #[cfg_attr(not(tarpaulin), inline(always))]
  pub fn set_label(&mut self, v: impl Into<SmolStr>) -> &mut Self {
    self.label = v.into();
    self
  }
}

#[cfg(test)]
mod tests;