Skip to content

Commit

Permalink
WIP mirroring size/scale comparison
Browse files Browse the repository at this point in the history
To determine if `mirroring_state` is needed, we want to compare the
untransformed dimensions of the source output to the target outputs
mode. The fact the mode comparision previously compared refresh rate
(since it compared the whole `Mode`) seems unintended.

We should also re-create the `MirroringState` when the source output
dimensions changes.

Not sure the exact best API here...
  • Loading branch information
ids1024 committed Dec 24, 2024
1 parent 08ff40f commit a30eb5c
Showing 1 changed file with 54 additions and 22 deletions.
76 changes: 54 additions & 22 deletions src/backend/kms/surface/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -147,26 +147,52 @@ pub struct SurfaceThreadState {
egui: EguiState,
}

#[derive(Debug, PartialEq)]
struct MirroringOutputConfig {
size: Size<i32, Physical>,
fractional_scale: f64,
}

impl MirroringOutputConfig {
fn for_output_untransformed(output: &Output) -> Self {
Self {
// Apply inverse of output transform to mode size to get correct size
// for an untransformed render.
size: output.current_transform().invert().transform_size(
output
.current_mode()
.map(|mode| mode.size)
.unwrap_or_default(),
),
fractional_scale: output.current_scale().fractional_scale(),
}
}

fn for_output(output: &Output) -> Self {
Self {
size: output
.current_mode()
.map(|mode| mode.size)
.unwrap_or_default(),
fractional_scale: output.current_scale().fractional_scale(),
}
}
}

#[derive(Debug)]
struct MirroringState {
texture: TextureRenderBuffer<GlesTexture>,
damage_tracker: OutputDamageTracker,
output_config: MirroringOutputConfig,
}

impl MirroringState {
fn new_with_renderer(
renderer: &mut GlMultiRenderer,
format: Fourcc,
output: &Output,
output_config: MirroringOutputConfig,
) -> Result<Self> {
// Apply inverse of output transform to mode size to get correct size
// for an untransformed render.
let size = output.current_transform().invert().transform_size(
output
.current_mode()
.map(|mode| mode.size)
.unwrap_or_default(),
);
let size = output_config.size;
let buffer_size = size.to_logical(1).to_buffer(1, Transform::Normal);
let opaque_regions = vec![Rectangle::from_loc_and_size((0, 0), buffer_size)];

Expand All @@ -180,15 +206,13 @@ impl MirroringState {
);

// Don't use `from_output` to avoid applying output transform
let damage_tracker = OutputDamageTracker::new(
size,
output.current_scale().fractional_scale(),
Transform::Normal,
);
let damage_tracker =
OutputDamageTracker::new(size, output_config.fractional_scale, Transform::Normal);

Ok(MirroringState {
texture: texture_buffer,
damage_tracker,
output_config,
})
}
}
Expand Down Expand Up @@ -1090,20 +1114,28 @@ impl SurfaceThreadState {

// actual rendering
let res = if let Some(mirrored_output) = self.mirroring.as_ref().filter(|mirrored_output| {
mirrored_output.current_mode().is_some_and(|mirror_mode| {
self.output
.current_mode()
.is_some_and(|mode| mode != mirror_mode)
}) || mirrored_output.current_scale().fractional_scale()
!= self.output.current_scale().fractional_scale()
MirroringOutputConfig::for_output_untransformed(mirrored_output)
!= MirroringOutputConfig::for_output(&self.output)
}) {
let mirrored_output_config =
MirroringOutputConfig::for_output_untransformed(mirrored_output);
let mirroring_state = match self.mirroring_textures.entry(self.target_node) {
hash_map::Entry::Occupied(occupied) => occupied.into_mut(),
hash_map::Entry::Occupied(occupied) => {
let mirroring_state = occupied.into_mut();
if mirroring_state.output_config != mirrored_output_config {
*mirroring_state = MirroringState::new_with_renderer(
&mut renderer,
compositor.format(),
mirrored_output_config,
)?
}
mirroring_state
}
hash_map::Entry::Vacant(vacant) => {
vacant.insert(MirroringState::new_with_renderer(
&mut renderer,
compositor.format(),
mirrored_output,
mirrored_output_config,
)?)
}
};
Expand Down

0 comments on commit a30eb5c

Please sign in to comment.