Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
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"
);
}
}
}