Merge pull request #1107 from mahkoh/jorth-drm-property-value

drm: add PrepareDrmObjectProperties trait

Author: mahkoh

algorithms/src/triangles.rs

@@ -35,6 +35,7 @@ pub fn triangle_contains_points(triangle: [[f64; 2]; 3], points: [[f64; 2]; 3])
         }
     }
     let mut bad = false;
+    #[expect(clippy::needless_range_loop)]
     for i in 0..3 {
         bad |= class[i] == 0b11;
     }

jay-proc/src/drm_object_properties.rs

@@ -0,0 +1,124 @@
+use {
+    proc_macro2::{Ident, Span},
+    quote::{quote, quote_spanned},
+    syn::{
+        Error, Generics, Item, ItemStruct, LitStr,
+        parse::{Parse, ParseStream},
+        parse_macro_input,
+        spanned::Spanned,
+    },
+};
+
+pub fn derive_prepare_drm_object_properties(
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    let input: Input = parse_macro_input!(input as Input);
+    let mut reset_body = vec![];
+    let mut update_body = vec![];
+    let mut prepare_body = vec![];
+    let mut differs_body = vec![];
+    let mut prepare_conditional_body = vec![];
+    for field in input.fields {
+        let name = LitStr::new(&field.to_string(), field.span());
+        reset_body.push(quote! {
+            crate::video::drm::PrepareDrmObjectProperty::reset(&mut self.#field);
+        });
+        update_body.push(quote! {
+            crate::video::drm::PrepareDrmObjectProperty::update(&mut self.#field, p);
+        });
+        prepare_body.push(quote! {
+            crate::video::drm::PrepareDrmObjectProperty::prepare(&self.#field, change, #name, logging);
+        });
+        differs_body.push(quote! {
+            crate::video::drm::PrepareDrmObjectProperty::differs(&self.#field, &old.#field)
+        });
+        prepare_conditional_body.push(quote! {
+            crate::video::drm::PrepareDrmObjectProperty::prepare_conditional(&self.#field, &old.#field, change, #name, logging);
+        });
+    }
+    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
+    let ident = input.ident;
+    let res = quote_spanned! { input.span =>
+        const _: () = {
+            impl #impl_generics
+            crate::utils::reset::Reset for #ident #type_generics
+            #where_clause
+            {
+                fn reset(&mut self) {
+                    #(#reset_body)*
+                }
+            }
+
+            impl #impl_generics
+            crate::video::drm::PrepareDrmObjectProperties for #ident #type_generics
+            #where_clause
+            {
+                fn update(
+                    &mut self,
+                    p: &crate::utils::bhash::BHashMap<crate::video::drm::DrmProperty, u64>,
+                ) {
+                    #(#update_body)*
+                }
+                fn prepare(
+                    &self,
+                    change: &mut crate::video::drm::ObjectChange<'_>,
+                    logging: Option<&crate::video::drm::Logging>,
+                ) {
+                    #(#prepare_body)*
+                }
+                fn differs(
+                    &self,
+                    old: &Self,
+                ) -> bool {
+                    #(#differs_body)||*
+                }
+                fn prepare_conditional(
+                    &self,
+                    old: &Self,
+                    change: &mut crate::video::drm::ObjectChange<'_>,
+                    logging: Option<&crate::video::drm::Logging>,
+                ) {
+                    #(#prepare_conditional_body)*
+                }
+            }
+        };
+    };
+    res.into()
+}
+
+struct Input {
+    span: Span,
+    ident: Ident,
+    generics: Generics,
+    fields: Vec<Ident>,
+}
+
+impl Input {
+    fn parse_struct(input: ItemStruct) -> syn::Result<Self> {
+        let span = input.span();
+        let mut fields = vec![];
+        for field in input.fields {
+            let span = field.span();
+            let ident = field
+                .ident
+                .ok_or(Error::new(span, "field names are required"))?;
+            fields.push(ident);
+        }
+        Ok(Self {
+            span,
+            ident: input.ident,
+            generics: input.generics,
+            fields,
+        })
+    }
+}
+
+impl Parse for Input {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let item: Item = input.parse()?;
+        match item {
+            Item::Struct(s) => Self::parse_struct(s),
+            _ => Err(Error::new(item.span(), "expected struct")),
+        }
+    }
+}

jay-proc/src/lib.rs

@@ -3,6 +3,7 @@ use {
     proc_macro::TokenStream,
 };
 
+mod drm_object_properties;
 mod markers;
 mod reset;
 
@@ -20,3 +21,8 @@ pub fn jay_clone(attr: TokenStream, item: TokenStream) -> TokenStream {
 pub fn jay_hash(attr: TokenStream, item: TokenStream) -> TokenStream {
     hash::derive_jay_hash(attr, item)
 }
+
+#[proc_macro_derive(PrepareDrmObjectProperties)]
+pub fn derive_prepare_drm_object_properties(input: TokenStream) -> TokenStream {
+    drm_object_properties::derive_prepare_drm_object_properties(input)
+}

src/backends/metal/present.rs

@@ -182,7 +182,7 @@ impl MetalConnector {
         if !self.backend.check_render_context(&self.dev) {
             return Ok(());
         }
-        if !crtc.drm_state.borrow().active {
+        if !crtc.drm_state.borrow().active.value {
             return Ok(());
         }
         let plane = match self.primary_plane.get() {
@@ -391,21 +391,21 @@ impl MetalConnector {
                     }
                 };
             changes.change_object(plane.id, |c| {
-                c.change(plane.fb_id, fb.fb.id());
-                drm_state.fb_id = fb.fb.id();
+                c.change(drm_state.fb_id.id, fb.fb.id());
+                drm_state.fb_id.value = fb.fb.id();
                 connector_state.fb = fb.fb.id();
                 connector_state.locked = fb.locked;
                 if fb.direct_scanout_data.is_none() {
                     connector_state.fb_idx += 1;
                 }
                 macro_rules! change {
                     ($prop:ident, $new:expr) => {{
-                        if drm_state.$prop != $new {
-                            c.change(plane.$prop, $new as u64);
+                        if drm_state.$prop.value != $new {
+                            c.change(drm_state.$prop.id, $new as u64);
                             try_async_flip = false;
-                            drm_state.$prop = $new;
+                            drm_state.$prop.value = $new;
                         }
-                        connector_state.$prop = drm_state.$prop;
+                        connector_state.$prop = drm_state.$prop.value;
                     }};
                 }
                 change!(src_w, (src_width as u32) << 16);
@@ -427,8 +427,8 @@ impl MetalConnector {
             changes.change_object(plane.id, |c| {
                 macro_rules! change {
                     ($prop:ident, $new:expr) => {{
-                        c.change(plane.$prop, $new);
-                        drm_state.$prop = $new;
+                        c.change(drm_state.$prop.id, $new);
+                        drm_state.$prop.value = $new;
                     }};
                 }
                 match &cursor.ty {