Add optional drv feature deriving drv::Input on identity types (algesten#974)

* Add optional drv feature deriving drv::Input on identity types

Adds a default-off `drv` feature that derives `drv::Input` (drv's
memoization cache-key plumbing) on the public identity types, so
downstream `#[drv::memo]` queries can take them by value as cache keys
without newtyping them to satisfy drv's ToStatic bound (the orphan rule
blocks a consumer-side impl on str0m's foreign types).

Types covered: Mid, Rid, Ssrc, Pt, SessionId, SeqNo, Direction,
MediaKind, Frequency, Codec, CodecSpec, FormatParams, VideoOrientation,
and the H265 profile types (H265ProfileTierLevel, H265Profile, H265Tier,
H265Level) — the last of which FormatParams transitively requires.

Frequency(NonZeroU32) relies on drv 0.4.3's NonZero ToStatic impls. The
feature is off by default, so non-drv consumers pay no dependency.
Support MediaTime as a drv::Input via an identity ToStatic impl

MediaTime's PartialEq rebases to a common timebase before comparing, so
the structural drv::Input derive would diverge from its real equality.
It's Copy + 'static, so give it a hand-written identity ToStatic impl
that defers to that PartialEq — the same shape drv uses for primitives.

Author: lolgesten

Cargo.lock

@@ -59,6 +59,7 @@ subtle = "2.0.0"
 arrayvec = "0.7.6"
 serde = { version = "1.0.152", features = ["derive"] }
 dimpl = { version = "0.6.2", default-features = false }
+drv = { version = "0.4.3" }
 time = "0.3"
 base64ct = "1"
 
@@ -118,6 +119,13 @@ examples = ["rouille/rustls"]
 _internal_dont_use_log_stats = []
 _internal_test_exports = ["str0m-proto/_internal_test_exports", "is/_internal_test_exports"]
 
+# Derives `drv::Input` (drv's memoization cache-key plumbing) on the public
+# identity types — Mid, Rid, Ssrc, Pt, SessionId, SeqNo, Direction, MediaKind,
+# Frequency, Codec, CodecSpec, FormatParams, VideoOrientation, and the H265
+# profile types — so downstream `#[drv::memo]` queries can take them by value.
+# Off by default.
+drv = ["dep:drv"]
+
 [dependencies]
 tracing.workspace = true
 fastrand.workspace = true
@@ -135,6 +143,8 @@ dimpl.workspace = true
 str0m-proto = { workspace = true, features = ["dtls"] }
 is.workspace = true
 
+drv = { workspace = true, optional = true }
+
 # Crypto providers
 str0m-aws-lc-rs = { workspace = true, optional = true }
 str0m-rust-crypto = { workspace = true, optional = true }

Cargo.toml

@@ -8,6 +8,7 @@ use super::format_params::FormatParams;
 
 /// Codec specification
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct CodecSpec {
     /// The codec identifier.
     pub codec: Codec,
@@ -25,6 +26,7 @@ pub struct CodecSpec {
 
 /// Known codecs.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 #[non_exhaustive]
 #[allow(missing_docs)]
 pub enum Codec {

src/format/codec.rs

@@ -5,6 +5,7 @@ use crate::sdp::FormatParam;
 
 /// Codec specific format parameters.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Default, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct FormatParams {
     /// Opus specific parameter.
     ///

src/format/format_params.rs

@@ -7,6 +7,7 @@ use serde::{Deserialize, Serialize};
 /// Represents the three SDP fmtp parameters `profile-id`, `tier-flag`, and `level-id`
 /// as defined in RFC 7798 §7.1 and ITU-T H.265 Annex A.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct H265ProfileTierLevel {
     profile: H265Profile,
     tier: H265Tier,
@@ -94,6 +95,7 @@ impl From<(u8, u8, u8)> for H265ProfileTierLevel {
 
 /// H.265 profile as defined in ITU-T H.265 Annex A.
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub enum H265Profile {
     /// Main profile (profile_id=1).
     Main,
@@ -160,6 +162,7 @@ impl H265Profile {
 
 /// H.265 tier (Main or High).
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub enum H265Tier {
     /// Main tier (tier_flag=0).
     Main,
@@ -192,6 +195,7 @@ impl H265Tier {
 ///
 /// Level IDs are 30× the level number (e.g., Level 3.1 = 93).
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 #[repr(u8)]
 #[rustfmt::skip]
 pub enum H265Level {

src/packet/h265_profile.rs

@@ -67,6 +67,7 @@ mod payload;
 pub(crate) use payload::Payloader;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 /// Types of media.
 pub enum MediaKind {
     /// Audio media.

src/packet/mod.rs

@@ -4,6 +4,7 @@ use std::fmt;
 ///
 /// And also extmap direction.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub enum Direction {
     /// Send only direction.
     SendOnly,

src/rtp/dir.rs

@@ -1222,6 +1222,7 @@ impl fmt::Debug for ExtensionMap {
 
 /// How the video is rotated.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub enum VideoOrientation {
     /// Not rotated.
     Deg0 = 0,

src/rtp/ext.rs

@@ -123,6 +123,7 @@ macro_rules! num_id {
 /// 3 incoming StreamRx, but since they belong to the same media,
 /// the have the same `Mid`.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct Mid([u8; 16]);
 str_id!(Mid, "Mid", 16, 3);
 
@@ -134,6 +135,7 @@ str_id!(Mid, "Mid", 16, 3);
 /// In SDP this is an optional value that will be seen in [`MediaData`][crate::media::MediaData]
 /// if the remote peer is configured for simulcast.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct Rid([u8; 8]);
 str_id!(Rid, "Rid", 8, 3);
 
@@ -143,6 +145,7 @@ str_id!(Rid, "Rid", 8, 3);
 /// with at least one synchronization source. Multiple sources for the same stream happens
 /// for RTX (resend) and simulcast.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct Ssrc(u32);
 num_id!(Ssrc, u32);
 
@@ -163,13 +166,15 @@ impl Ssrc {
 ///
 /// PTs in RTP headers are 7 bits. Values >=128 are not valid.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct Pt(u8);
 num_id!(Pt, u8);
 
 /// Identifier of an SDP session.
 ///
 /// This value is rarely interesting, but is part of the SDP OFFER and ANSWER.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct SessionId(u64);
 num_id!(SessionId, u64);
 
@@ -194,6 +199,7 @@ num_id!(SessionId, u64);
 /// assert_eq!(b, 1);
 /// ```
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct SeqNo(u64);
 num_id!(SeqNo, u64);
 

src/rtp/id.rs

@@ -33,6 +33,7 @@ use serde::{Deserialize, Serialize};
 /// let mtime = MediaTime::new(2000, freq);
 /// ```
 #[derive(Debug, Clone, Copy, Serialize)]
+#[cfg_attr(feature = "drv", derive(drv::Input))]
 pub struct Frequency(NonZeroU32);
 
 impl Frequency {
@@ -332,6 +333,22 @@ impl PartialEq for MediaTime {
 }
 impl Eq for MediaTime {}
 
+// `MediaTime`'s `PartialEq` rebases to a common timebase before comparing,
+// so the structural `drv::Input` derive (raw numerator + frequency) would
+// diverge from its real equality. It's `Copy + 'static`, so give it an
+// identity `ToStatic` that defers to that `PartialEq` — mirroring how drv
+// treats primitives.
+#[cfg(feature = "drv")]
+impl drv::ToStatic for MediaTime {
+    type Static = MediaTime;
+    fn to_static(&self) -> MediaTime {
+        *self
+    }
+    fn eq_static(&self, other: &MediaTime) -> bool {
+        self == other
+    }
+}
+
 impl PartialOrd for MediaTime {
     #[inline(always)]
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {