Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

42.9 KB
Raw Blame
use cap_project::XY;

use std::sync::Arc;

use crate::{
    DecodedSegmentFrames, PixelFormat,
    composite_frame::{CompositeVideoFramePipeline, CompositeVideoFrameUniforms},
    decoder::DecodedFrameStorageIdentity,
    yuv_converter::{YuvConverterPipelines, YuvToRgbaConverter},
};

#[cfg(target_os = "macos")]
use crate::yuv_converter::RetainedImageBuf;

struct PendingTextureCopy {
    width: u32,
    height: u32,
    dst_texture_index: usize,
}

pub struct DisplayLayer {
    frame_textures: [wgpu::Texture; 2],
    frame_texture_views: [wgpu::TextureView; 2],
    current_texture: usize,
    uniforms_buffer: wgpu::Buffer,
    pipeline: std::sync::Arc<CompositeVideoFramePipeline>,
    bind_groups: [Option<wgpu::BindGroup>; 2],
    last_recording_time: Option<f32>,
    last_frame_storage: Option<DecodedFrameStorageIdentity>,
    yuv_converter: YuvToRgbaConverter,
    #[cfg(target_os = "macos")]
    frame_sources: [Option<RetainedImageBuf>; 2],
    pending_copy: Option<PendingTextureCopy>,
    prefer_cpu_conversion: bool,
    has_valid_frame: bool,
}

impl DisplayLayer {
    /// Forget the last frame shown, as a new layer would.
    pub(crate) fn reset_frame_state(&mut self) {
        self.last_recording_time = None;
        self.last_frame_storage = None;
        self.has_valid_frame = false;
    }

    #[allow(dead_code)]
    pub fn new(device: &wgpu::Device) -> Self {
        Self::new_with_options(device, false)
    }

    pub fn new_with_options(device: &wgpu::Device, prefer_cpu_conversion: bool) -> Self {
        Self::new_with_all_shared_pipelines(
            device,
            Arc::new(YuvConverterPipelines::new(device)),
            Arc::new(CompositeVideoFramePipeline::new(device)),
            prefer_cpu_conversion,
        )
    }

    pub fn new_with_all_shared_pipelines(
        device: &wgpu::Device,
        yuv_pipelines: Arc<YuvConverterPipelines>,
        composite_pipeline: Arc<CompositeVideoFramePipeline>,
        prefer_cpu_conversion: bool,
    ) -> Self {
        let frame_texture_0 = CompositeVideoFramePipeline::create_frame_texture(device, 1920, 1080);
        let frame_texture_1 = CompositeVideoFramePipeline::create_frame_texture(device, 1920, 1080);
        let frame_texture_view_0 = frame_texture_0.create_view(&Default::default());
        let frame_texture_view_1 = frame_texture_1.create_view(&Default::default());

        let uniforms_buffer = CompositeVideoFrameUniforms::default().to_buffer(device);
        let bind_group_0 =
            Some(composite_pipeline.bind_group(device, &uniforms_buffer, &frame_texture_view_0));
        let bind_group_1 =
            Some(composite_pipeline.bind_group(device, &uniforms_buffer, &frame_texture_view_1));

        let yuv_converter = YuvToRgbaConverter::new_with_shared_pipelines(device, yuv_pipelines);

        if prefer_cpu_conversion {
            tracing::info!("DisplayLayer initialized with CPU YUV conversion preference");
        }

        Self {
            frame_textures: [frame_texture_0, frame_texture_1],
            frame_texture_views: [frame_texture_view_0, frame_texture_view_1],
            current_texture: 0,
            uniforms_buffer,
            pipeline: composite_pipeline,
            bind_groups: [bind_group_0, bind_group_1],
            last_recording_time: None,
            last_frame_storage: None,
            yuv_converter,
            #[cfg(target_os = "macos")]
            frame_sources: [None, None],
            pending_copy: None,
            prefer_cpu_conversion,
            has_valid_frame: false,
        }
    }

    #[cfg(target_os = "windows")]
    fn try_d3d11_staging_fallback(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        screen_frame: &crate::DecodedFrame,
        actual_width: u32,
        actual_height: u32,
        next_texture: usize,
    ) -> bool {
        let Some(nv12_texture) = screen_frame.d3d11_texture_backing() else {
            return false;
        };

        let Ok(d3d11_device) = (unsafe { nv12_texture.GetDevice() }) else {
            return false;
        };

        let Ok(d3d11_context) = (unsafe { d3d11_device.GetImmediateContext() }) else {
            return false;
        };

        if self
            .yuv_converter
            .convert_nv12_with_fallback(
                device,
                queue,
                &d3d11_device,
                &d3d11_context,
                nv12_texture,
                screen_frame.d3d11_y_handle(),
                screen_frame.d3d11_uv_handle(),
                actual_width,
                actual_height,
            )
            .is_ok()
            && self.yuv_converter.output_texture().is_some()
        {
            self.pending_copy = Some(PendingTextureCopy {
                width: actual_width,
                height: actual_height,
                dst_texture_index: next_texture,
            });
            true
        } else {
            false
        }
    }

    pub fn prepare(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        segment_frames: &DecodedSegmentFrames,
        frame_size: XY<u32>,
        uniforms: CompositeVideoFrameUniforms,
    ) -> (bool, u32, u32) {
        self.pending_copy = None;

        let Some(screen_frame) = &segment_frames.screen_frame else {
            tracing::debug!(
                "DisplayLayer::prepare - screen_frame is None, skipping display rendering"
            );
            uniforms.write_to_buffer(queue, &self.uniforms_buffer);
            return (false, frame_size.x, frame_size.y);
        };

        let actual_width = screen_frame.width();
        let actual_height = screen_frame.height();
        let source_size = XY::new(actual_width, actual_height);
        let format = screen_frame.format();
        self.yuv_converter.set_matrix(screen_frame.matrix());
        let current_recording_time = segment_frames.recording_time;
        let frame_storage = screen_frame.storage_identity();

        let skipped = self
            .last_frame_storage
            .as_ref()
            .is_some_and(|last| last.matches(&frame_storage))
            || self
                .last_recording_time
                .is_some_and(|last| (last - current_recording_time).abs() < 0.001);

        let mut frame_uploaded = false;

        if !skipped {
            let next_texture = 1 - self.current_texture;

            if self.frame_textures[next_texture].width() != source_size.x
                || self.frame_textures[next_texture].height() != source_size.y
            {
                self.frame_textures[next_texture] =
                    CompositeVideoFramePipeline::create_frame_texture(
                        device,
                        source_size.x,
                        source_size.y,
                    );
                self.frame_texture_views[next_texture] =
                    self.frame_textures[next_texture].create_view(&Default::default());

                self.bind_groups[next_texture] = Some(self.pipeline.bind_group(
                    device,
                    &self.uniforms_buffer,
                    &self.frame_texture_views[next_texture],
                ));
            }

            frame_uploaded = match format {
                PixelFormat::Rgba => {
                    let frame_data = screen_frame.data();
                    let src_bytes_per_row = source_size.x * 4;

                    queue.write_texture(
                        wgpu::TexelCopyTextureInfo {
                            texture: &self.frame_textures[next_texture],
                            mip_level: 0,
                            origin: wgpu::Origin3d::ZERO,
                            aspect: wgpu::TextureAspect::All,
                        },
                        frame_data,
                        wgpu::TexelCopyBufferLayout {
                            offset: 0,
                            bytes_per_row: Some(src_bytes_per_row),
                            rows_per_image: Some(source_size.y),
                        },
                        wgpu::Extent3d {
                            width: source_size.x,
                            height: source_size.y,
                            depth_or_array_layers: 1,
                        },
                    );
                    true
                }
                PixelFormat::Nv12 => {
                    #[cfg(target_os = "macos")]
                    if !self.prefer_cpu_conversion {
                        let iosurface_converted = screen_frame
                            .with_image_buf(|image_buf| {
                                self.yuv_converter
                                    .convert_nv12_from_iosurface(device, queue, image_buf)
                                    .is_ok()
                            })
                            .unwrap_or(false);

                        if iosurface_converted && self.yuv_converter.output_texture().is_some() {
                            self.pending_copy = Some(PendingTextureCopy {
                                width: source_size.x,
                                height: source_size.y,
                                dst_texture_index: next_texture,
                            });
                            true
                        } else if let (Some(y_data), Some(uv_data)) =
                            (screen_frame.y_plane(), screen_frame.uv_plane())
                        {
                            let y_stride = screen_frame.y_stride();
                            let uv_stride = screen_frame.uv_stride();
                            let convert_result = self.yuv_converter.convert_nv12(
                                device,
                                queue,
                                y_data,
                                uv_data,
                                source_size.x,
                                source_size.y,
                                y_stride,
                                uv_stride,
                            );

                            match convert_result {
                                Ok(_) => {
                                    if self.yuv_converter.output_texture().is_some() {
                                        self.pending_copy = Some(PendingTextureCopy {
                                            width: source_size.x,
                                            height: source_size.y,
                                            dst_texture_index: next_texture,
                                        });
                                        true
                                    } else {
                                        false
                                    }
                                }
                                Err(_) => false,
                            }
                        } else {
                            false
                        }
                    } else if let (Some(y_data), Some(uv_data)) =
                        (screen_frame.y_plane(), screen_frame.uv_plane())
                    {
                        let y_stride = screen_frame.y_stride();
                        let uv_stride = screen_frame.uv_stride();
                        let convert_result = self.yuv_converter.convert_nv12_cpu(
                            device,
                            queue,
                            y_data,
                            uv_data,
                            source_size.x,
                            source_size.y,
                            y_stride,
                            uv_stride,
                        );

                        match convert_result {
                            Ok(_) => {
                                if self.yuv_converter.output_texture().is_some() {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: source_size.x,
                                        height: source_size.y,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                } else {
                                    false
                                }
                            }
                            Err(_) => false,
                        }
                    } else {
                        false
                    }

                    #[cfg(target_os = "windows")]
                    {
                        let mut d3d11_succeeded = false;

                        if self.yuv_converter.is_using_zero_copy()
                            && let (Some(y_handle), Some(uv_handle)) = (
                                screen_frame.d3d11_y_handle(),
                                screen_frame.d3d11_uv_handle(),
                            )
                            && self
                                .yuv_converter
                                .convert_nv12_from_d3d11_shared_handles(
                                    device,
                                    queue,
                                    y_handle,
                                    uv_handle,
                                    actual_width,
                                    actual_height,
                                )
                                .is_ok()
                            && self.yuv_converter.output_texture().is_some()
                        {
                            self.pending_copy = Some(PendingTextureCopy {
                                width: actual_width,
                                height: actual_height,
                                dst_texture_index: next_texture,
                            });
                            d3d11_succeeded = true;
                        }

                        if d3d11_succeeded {
                            true
                        } else if let (Some(y_data), Some(uv_data)) =
                            (screen_frame.y_plane(), screen_frame.uv_plane())
                        {
                            let y_stride = screen_frame.y_stride();
                            let uv_stride = screen_frame.uv_stride();

                            let convert_ok = if self.prefer_cpu_conversion {
                                self.yuv_converter
                                    .convert_nv12_cpu(
                                        device,
                                        queue,
                                        y_data,
                                        uv_data,
                                        actual_width,
                                        actual_height,
                                        y_stride,
                                        uv_stride,
                                    )
                                    .is_ok()
                            } else {
                                self.yuv_converter
                                    .convert_nv12(
                                        device,
                                        queue,
                                        y_data,
                                        uv_data,
                                        actual_width,
                                        actual_height,
                                        y_stride,
                                        uv_stride,
                                    )
                                    .is_ok()
                            };

                            let has_output = self.yuv_converter.output_texture().is_some();

                            if convert_ok && has_output {
                                self.pending_copy = Some(PendingTextureCopy {
                                    width: actual_width,
                                    height: actual_height,
                                    dst_texture_index: next_texture,
                                });
                                true
                            } else {
                                false
                            }
                        } else {
                            self.try_d3d11_staging_fallback(
                                device,
                                queue,
                                screen_frame,
                                actual_width,
                                actual_height,
                                next_texture,
                            )
                        }
                    }

                    #[cfg(not(any(target_os = "macos", target_os = "windows")))]
                    {
                        #[cfg(target_os = "linux")]
                        let cuda_result = screen_frame.cuda_nv12().map(|cuda| {
                            let converted = self
                                .yuv_converter
                                .convert_nv12_cuda(device, queue, cuda)
                                .map(|_| ());
                            match converted {
                                Ok(()) if self.yuv_converter.output_texture().is_some() => {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: source_size.x,
                                        height: source_size.y,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                }
                                Ok(()) => false,
                                Err(error) => {
                                    tracing::warn!(%error, "CUDA frame conversion failed");
                                    false
                                }
                            }
                        });
                        #[cfg(not(target_os = "linux"))]
                        let cuda_result: Option<bool> = None;
                        if let Some(converted) = cuda_result {
                            converted
                        } else if let (Some(y_data), Some(uv_data)) =
                            (screen_frame.y_plane(), screen_frame.uv_plane())
                        {
                            let y_stride = screen_frame.y_stride();
                            let uv_stride = screen_frame.uv_stride();

                            let convert_result = if self.prefer_cpu_conversion {
                                self.yuv_converter.convert_nv12_cpu(
                                    device,
                                    queue,
                                    y_data,
                                    uv_data,
                                    source_size.x,
                                    source_size.y,
                                    y_stride,
                                    uv_stride,
                                )
                            } else {
                                self.yuv_converter.convert_nv12(
                                    device,
                                    queue,
                                    y_data,
                                    uv_data,
                                    source_size.x,
                                    source_size.y,
                                    y_stride,
                                    uv_stride,
                                )
                            };

                            match convert_result {
                                Ok(_) => {
                                    if self.yuv_converter.output_texture().is_some() {
                                        self.pending_copy = Some(PendingTextureCopy {
                                            width: source_size.x,
                                            height: source_size.y,
                                            dst_texture_index: next_texture,
                                        });
                                        true
                                    } else {
                                        false
                                    }
                                }
                                Err(_) => false,
                            }
                        } else {
                            false
                        }
                    }
                }
                PixelFormat::Yuv420p => {
                    let y_plane = screen_frame.y_plane();
                    let u_plane = screen_frame.u_plane();
                    let v_plane = screen_frame.v_plane();

                    if let (Some(y_data), Some(u_data), Some(v_data)) = (y_plane, u_plane, v_plane)
                    {
                        let convert_result = if self.prefer_cpu_conversion {
                            self.yuv_converter.convert_yuv420p_cpu(
                                device,
                                queue,
                                y_data,
                                u_data,
                                v_data,
                                source_size.x,
                                source_size.y,
                                screen_frame.y_stride(),
                                screen_frame.uv_stride(),
                            )
                        } else {
                            self.yuv_converter.convert_yuv420p(
                                device,
                                queue,
                                y_data,
                                u_data,
                                v_data,
                                source_size.x,
                                source_size.y,
                                screen_frame.y_stride(),
                                screen_frame.uv_stride(),
                            )
                        };

                        match convert_result {
                            Ok(_) => {
                                if self.yuv_converter.output_texture().is_some() {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: source_size.x,
                                        height: source_size.y,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                } else {
                                    false
                                }
                            }
                            Err(_) => false,
                        }
                    } else {
                        false
                    }
                }
            };

            if frame_uploaded {
                self.last_recording_time = Some(current_recording_time);
                self.last_frame_storage = Some(frame_storage);
                self.current_texture = next_texture;
                self.has_valid_frame = true;
            } else {
                tracing::warn!(
                    recording_time = current_recording_time,
                    width = actual_width,
                    height = actual_height,
                    format = ?format,
                    "Display frame upload failed"
                );
            }
        }

        uniforms.write_to_buffer(queue, &self.uniforms_buffer);
        (
            (skipped && self.has_valid_frame) || frame_uploaded,
            actual_width,
            actual_height,
        )
    }

    pub fn prepare_with_encoder(
        &mut self,
        device: &wgpu::Device,
        queue: &wgpu::Queue,
        segment_frames: &DecodedSegmentFrames,
        uniforms: CompositeVideoFrameUniforms,
        encoder: &mut wgpu::CommandEncoder,
    ) -> bool {
        self.pending_copy = None;

        let Some(screen_frame) = &segment_frames.screen_frame else {
            tracing::debug!(
                "DisplayLayer::prepare_with_encoder - screen_frame is None, skipping display rendering"
            );
            uniforms.write_to_buffer(queue, &self.uniforms_buffer);
            return false;
        };

        let actual_width = screen_frame.width();
        let actual_height = screen_frame.height();
        let source_size = XY::new(actual_width, actual_height);
        let format = screen_frame.format();
        self.yuv_converter.set_matrix(screen_frame.matrix());
        let current_recording_time = segment_frames.recording_time;
        let frame_storage = screen_frame.storage_identity();

        let skipped = self
            .last_frame_storage
            .as_ref()
            .is_some_and(|last| last.matches(&frame_storage))
            || self
                .last_recording_time
                .is_some_and(|last| (last - current_recording_time).abs() < 0.001);

        let mut frame_uploaded = false;

        if !skipped {
            let next_texture = 1 - self.current_texture;

            if self.frame_textures[next_texture].width() != source_size.x
                || self.frame_textures[next_texture].height() != source_size.y
            {
                self.frame_textures[next_texture] =
                    CompositeVideoFramePipeline::create_frame_texture(
                        device,
                        source_size.x,
                        source_size.y,
                    );
                self.frame_texture_views[next_texture] =
                    self.frame_textures[next_texture].create_view(&Default::default());

                self.bind_groups[next_texture] = Some(self.pipeline.bind_group(
                    device,
                    &self.uniforms_buffer,
                    &self.frame_texture_views[next_texture],
                ));
            }

            #[cfg(target_os = "macos")]
            let mut frame_source = None;

            frame_uploaded = match format {
                PixelFormat::Rgba => {
                    let frame_data = screen_frame.data();
                    let src_bytes_per_row = source_size.x * 4;

                    queue.write_texture(
                        wgpu::TexelCopyTextureInfo {
                            texture: &self.frame_textures[next_texture],
                            mip_level: 0,
                            origin: wgpu::Origin3d::ZERO,
                            aspect: wgpu::TextureAspect::All,
                        },
                        frame_data,
                        wgpu::TexelCopyBufferLayout {
                            offset: 0,
                            bytes_per_row: Some(src_bytes_per_row),
                            rows_per_image: Some(source_size.y),
                        },
                        wgpu::Extent3d {
                            width: source_size.x,
                            height: source_size.y,
                            depth_or_array_layers: 1,
                        },
                    );
                    true
                }
                PixelFormat::Nv12 => {
                    #[cfg(target_os = "windows")]
                    let d3d11_zero_copy_succeeded = {
                        let mut succeeded = false;
                        if !self.prefer_cpu_conversion
                            && self.yuv_converter.is_using_zero_copy()
                            && let (Some(y_handle), Some(uv_handle)) = (
                                screen_frame.d3d11_y_handle(),
                                screen_frame.d3d11_uv_handle(),
                            )
                            && self
                                .yuv_converter
                                .convert_nv12_from_d3d11_shared_handles(
                                    device,
                                    queue,
                                    y_handle,
                                    uv_handle,
                                    actual_width,
                                    actual_height,
                                )
                                .is_ok()
                            && self.yuv_converter.output_texture().is_some()
                        {
                            self.pending_copy = Some(PendingTextureCopy {
                                width: actual_width,
                                height: actual_height,
                                dst_texture_index: next_texture,
                            });
                            succeeded = true;
                        }
                        succeeded
                    };

                    #[cfg(target_os = "windows")]
                    if d3d11_zero_copy_succeeded {
                        true
                    } else if !self.prefer_cpu_conversion {
                        if let (Some(y_data), Some(uv_data)) =
                            (screen_frame.y_plane(), screen_frame.uv_plane())
                        {
                            let y_stride = screen_frame.y_stride();
                            let uv_stride = screen_frame.uv_stride();

                            let convert_result = self.yuv_converter.convert_nv12_to_encoder(
                                device,
                                queue,
                                encoder,
                                y_data,
                                uv_data,
                                actual_width,
                                actual_height,
                                y_stride,
                                uv_stride,
                            );

                            match convert_result {
                                Ok(_) => {
                                    if self.yuv_converter.output_texture().is_some() {
                                        self.pending_copy = Some(PendingTextureCopy {
                                            width: actual_width,
                                            height: actual_height,
                                            dst_texture_index: next_texture,
                                        });
                                        true
                                    } else {
                                        false
                                    }
                                }
                                Err(_) => false,
                            }
                        } else {
                            self.try_d3d11_staging_fallback(
                                device,
                                queue,
                                screen_frame,
                                actual_width,
                                actual_height,
                                next_texture,
                            )
                        }
                    } else if let (Some(y_data), Some(uv_data)) =
                        (screen_frame.y_plane(), screen_frame.uv_plane())
                    {
                        let y_stride = screen_frame.y_stride();
                        let uv_stride = screen_frame.uv_stride();
                        let convert_result = self.yuv_converter.convert_nv12_cpu(
                            device,
                            queue,
                            y_data,
                            uv_data,
                            actual_width,
                            actual_height,
                            y_stride,
                            uv_stride,
                        );

                        match convert_result {
                            Ok(_) => {
                                if self.yuv_converter.output_texture().is_some() {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: actual_width,
                                        height: actual_height,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                } else {
                                    false
                                }
                            }
                            Err(_) => false,
                        }
                    } else {
                        self.try_d3d11_staging_fallback(
                            device,
                            queue,
                            screen_frame,
                            actual_width,
                            actual_height,
                            next_texture,
                        )
                    }

                    #[cfg(not(target_os = "windows"))]
                    if !self.prefer_cpu_conversion {
                        #[cfg(target_os = "macos")]
                        let converted_into_frame = {
                            frame_source = screen_frame
                                .with_image_buf(|image_buf| {
                                    self.yuv_converter
                                        .convert_nv12_from_iosurface_into(
                                            device,
                                            encoder,
                                            image_buf,
                                            &self.frame_texture_views[next_texture],
                                        )
                                        .ok()
                                })
                                .flatten();
                            frame_source.is_some()
                        };
                        #[cfg(not(target_os = "macos"))]
                        let converted_into_frame = false;
                        // Submitted ahead of `encoder`, so the conversion
                        // lands before the pending copy recorded below.
                        #[cfg(target_os = "linux")]
                        let iosurface_converted = screen_frame.cuda_nv12().is_some_and(|cuda| {
                            self.yuv_converter
                                .convert_nv12_cuda(device, queue, cuda)
                                .inspect_err(
                                    |error| tracing::warn!(%error, "CUDA frame conversion failed"),
                                )
                                .is_ok()
                        });
                        #[cfg(not(target_os = "linux"))]
                        let iosurface_converted = false;

                        if converted_into_frame {
                            true
                        } else if iosurface_converted
                            && self.yuv_converter.output_texture().is_some()
                        {
                            self.pending_copy = Some(PendingTextureCopy {
                                width: source_size.x,
                                height: source_size.y,
                                dst_texture_index: next_texture,
                            });
                            true
                        } else if let (Some(y_data), Some(uv_data)) =
                            (screen_frame.y_plane(), screen_frame.uv_plane())
                        {
                            let y_stride = screen_frame.y_stride();
                            let uv_stride = screen_frame.uv_stride();

                            let convert_result = self.yuv_converter.convert_nv12_to_encoder(
                                device,
                                queue,
                                encoder,
                                y_data,
                                uv_data,
                                source_size.x,
                                source_size.y,
                                y_stride,
                                uv_stride,
                            );

                            match convert_result {
                                Ok(_) => {
                                    if self.yuv_converter.output_texture().is_some() {
                                        self.pending_copy = Some(PendingTextureCopy {
                                            width: source_size.x,
                                            height: source_size.y,
                                            dst_texture_index: next_texture,
                                        });
                                        true
                                    } else {
                                        false
                                    }
                                }
                                Err(_) => false,
                            }
                        } else {
                            false
                        }
                    } else if let (Some(y_data), Some(uv_data)) =
                        (screen_frame.y_plane(), screen_frame.uv_plane())
                    {
                        let y_stride = screen_frame.y_stride();
                        let uv_stride = screen_frame.uv_stride();
                        let convert_result = self.yuv_converter.convert_nv12_cpu(
                            device,
                            queue,
                            y_data,
                            uv_data,
                            source_size.x,
                            source_size.y,
                            y_stride,
                            uv_stride,
                        );

                        match convert_result {
                            Ok(_) => {
                                if self.yuv_converter.output_texture().is_some() {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: source_size.x,
                                        height: source_size.y,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                } else {
                                    false
                                }
                            }
                            Err(_) => false,
                        }
                    } else {
                        false
                    }
                }
                PixelFormat::Yuv420p => {
                    let y_plane = screen_frame.y_plane();
                    let u_plane = screen_frame.u_plane();
                    let v_plane = screen_frame.v_plane();

                    if let (Some(y_data), Some(u_data), Some(v_data)) = (y_plane, u_plane, v_plane)
                    {
                        let convert_result = if self.prefer_cpu_conversion {
                            self.yuv_converter.convert_yuv420p_cpu(
                                device,
                                queue,
                                y_data,
                                u_data,
                                v_data,
                                source_size.x,
                                source_size.y,
                                screen_frame.y_stride(),
                                screen_frame.uv_stride(),
                            )
                        } else {
                            self.yuv_converter.convert_yuv420p_to_encoder(
                                device,
                                queue,
                                encoder,
                                y_data,
                                u_data,
                                v_data,
                                source_size.x,
                                source_size.y,
                                screen_frame.y_stride(),
                                screen_frame.uv_stride(),
                            )
                        };

                        match convert_result {
                            Ok(_) => {
                                if self.yuv_converter.output_texture().is_some() {
                                    self.pending_copy = Some(PendingTextureCopy {
                                        width: source_size.x,
                                        height: source_size.y,
                                        dst_texture_index: next_texture,
                                    });
                                    true
                                } else {
                                    false
                                }
                            }
                            Err(_) => false,
                        }
                    } else {
                        false
                    }
                }
            };

            if frame_uploaded {
                #[cfg(target_os = "macos")]
                RetainedImageBuf::replace(
                    queue,
                    &mut self.frame_sources[next_texture],
                    frame_source,
                );
                self.last_recording_time = Some(current_recording_time);
                self.last_frame_storage = Some(frame_storage);
                self.current_texture = next_texture;
                self.has_valid_frame = true;
            } else {
                tracing::warn!(
                    recording_time = current_recording_time,
                    width = actual_width,
                    height = actual_height,
                    format = ?format,
                    "Display frame upload failed"
                );
            }
        }

        uniforms.write_to_buffer(queue, &self.uniforms_buffer);
        (skipped && self.has_valid_frame) || frame_uploaded
    }

    pub fn copy_to_texture(&mut self, encoder: &mut wgpu::CommandEncoder) {
        let Some(pending) = self.pending_copy.take() else {
            return;
        };

        let Some(src_texture) = self.yuv_converter.output_texture() else {
            tracing::warn!("copy_to_texture: no source texture from YUV converter");
            return;
        };

        encoder.copy_texture_to_texture(
            wgpu::TexelCopyTextureInfo {
                texture: src_texture,
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::TexelCopyTextureInfo {
                texture: &self.frame_textures[pending.dst_texture_index],
                mip_level: 0,
                origin: wgpu::Origin3d::ZERO,
                aspect: wgpu::TextureAspect::All,
            },
            wgpu::Extent3d {
                width: pending.width,
                height: pending.height,
                depth_or_array_layers: 1,
            },
        );
    }

    pub fn render(&self, pass: &mut wgpu::RenderPass<'_>) {
        if !self.has_valid_frame {
            return;
        }

        if let Some(bind_group) = &self.bind_groups[self.current_texture] {
            pass.set_pipeline(&self.pipeline.render_pipeline);
            pass.set_bind_group(0, bind_group, &[]);
            pass.draw(0..3, 0..1);
        } else {
            tracing::warn!(
                current_texture_index = self.current_texture,
                "DisplayLayer::render - no bind group available"
            );
        }
    }

    pub fn has_valid_frame(&self) -> bool {
        self.has_valid_frame
    }

    pub fn prepare_for_video_dimensions(&mut self, device: &wgpu::Device, width: u32, height: u32) {
        if let Err(e) = self
            .yuv_converter
            .prepare_for_dimensions(device, width, height)
        {
            tracing::warn!(
                width = width,
                height = height,
                error = ?e,
                "Failed to pre-allocate YUV converter textures"
            );
        }
    }
}