fixup! [wgpu-core] Create default ExternalTextureParams buffer

Author: jamienicol

wgpu-core/src/device/resource.rs

@@ -175,8 +175,9 @@ pub struct Device {
         OnceCellOrLock<crate::timestamp_normalization::TimestampNormalizer>,
     /// Uniform buffer containing [`ExternalTextureParams`] with values such
     /// that a [`TextureView`] bound to a [`wgt::BindingType::ExternalTexture`]
-    /// binding point will be rendered correctly.
-    pub(crate) default_external_texture_params_buffer: std::sync::OnceLock<Arc<Buffer>>,
+    /// binding point will be rendered correctly. Intended to be used as the
+    /// [`hal::ExternalTextureBinding::params`] field.
+    pub(crate) default_external_texture_params_buffer: ManuallyDrop<Box<dyn hal::DynBuffer>>,
     // needs to be dropped last
     #[cfg(feature = "trace")]
     pub(crate) trace: Mutex<Option<trace::Trace>>,
@@ -204,6 +205,10 @@ impl Drop for Device {
 
         // SAFETY: We are in the Drop impl and we don't use self.zero_buffer anymore after this point.
         let zero_buffer = unsafe { ManuallyDrop::take(&mut self.zero_buffer) };
+        // SAFETY: We are in the Drop impl and we don't use
+        // self.default_external_texture_params_buffer anymore after this point.
+        let default_external_texture_params_buffer =
+            unsafe { ManuallyDrop::take(&mut self.default_external_texture_params_buffer) };
         // SAFETY: We are in the Drop impl and we don't use self.fence anymore after this point.
         let fence = unsafe { ManuallyDrop::take(&mut self.fence.write()) };
         if let Some(indirect_validation) = self.indirect_validation.take() {
@@ -214,6 +219,8 @@ impl Drop for Device {
         }
         unsafe {
             self.raw.destroy_buffer(zero_buffer);
+            self.raw
+                .destroy_buffer(default_external_texture_params_buffer);
             self.raw.destroy_fence(fence);
         }
     }
@@ -293,6 +300,19 @@ impl Device {
         }
         .map_err(DeviceError::from_hal)?;
 
+        let default_external_texture_params_buffer = unsafe {
+            raw_device.create_buffer(&hal::BufferDescriptor {
+                label: hal_label(
+                    Some("(wgpu internal) default external texture params buffer"),
+                    instance_flags,
+                ),
+                size: size_of::<ExternalTextureParams>() as _,
+                usage: wgt::BufferUses::COPY_DST | wgt::BufferUses::UNIFORM,
+                memory_flags: hal::MemoryFlags::empty(),
+            })
+        }
+        .map_err(DeviceError::from_hal)?;
+
         let alignments = adapter.raw.capabilities.alignments.clone();
         let downlevel = adapter.raw.capabilities.downlevel.clone();
 
@@ -318,7 +338,9 @@ impl Device {
             adapter: adapter.clone(),
             queue: OnceCellOrLock::new(),
             zero_buffer: ManuallyDrop::new(zero_buffer),
-            default_external_texture_params_buffer: std::sync::OnceLock::new(),
+            default_external_texture_params_buffer: ManuallyDrop::new(
+                default_external_texture_params_buffer,
+            ),
             label: desc.label.to_string(),
             command_allocator,
             command_indices: RwLock::new(
@@ -369,19 +391,12 @@ impl Device {
         })
     }
 
-    pub fn late_init_resources_with_queue(self: &Arc<Self>) -> Result<(), RequestDeviceError> {
-        let queue = self.get_queue().unwrap();
-
-        let timestamp_normalizer = crate::timestamp_normalization::TimestampNormalizer::new(
-            self,
-            queue.get_timestamp_period(),
-        )?;
-
-        self.timestamp_normalizer
-            .set(timestamp_normalizer)
-            .unwrap_or_else(|_| panic!("Called late_init_resources_with_queue twice"));
-
-        let params_data = ExternalTextureParams {
+    /// Initializes [`Device::default_external_texture_params_buffer`] with
+    /// required values such that a [`TextureView`] bound to a
+    /// [`wgt::BindingType::ExternalTexture`] binding point will be rendered
+    /// correctly.
+    fn init_default_external_texture_params_buffer(self: &Arc<Self>) -> Result<(), DeviceError> {
+        let data = ExternalTextureParams {
             #[rustfmt::skip]
             yuv_conversion_matrix: [
                 1.0, 0.0, 0.0, 0.0,
@@ -398,33 +413,63 @@ impl Device {
             ],
             num_planes: 1,
         };
-        let params_buffer = self
-            .create_buffer(&resource::BufferDescriptor {
-                label: Some(Cow::Borrowed(
-                    "(wgpu internal) default external texture params buffer",
-                )),
-                size: size_of_val(&params_data) as wgt::BufferAddress,
-                usage: wgt::BufferUsages::UNIFORM | wgt::BufferUsages::COPY_DST,
-                mapped_at_creation: false,
-            })
-            .map_err(|err| match err {
-                resource::CreateBufferError::Device(device) => RequestDeviceError::Device(device),
-                _ => unreachable!("Error creating default external texture params buffer: {err:?}"),
-            })?;
-        queue
-            .write_buffer(
-                Fallible::Valid(params_buffer.clone()),
-                0,
-                bytemuck::bytes_of(&params_data),
-            )
-            .map_err(|err| match err {
-                super::queue::QueueWriteError::Queue(device) => RequestDeviceError::Device(device),
-                _ => unreachable!("Error writing default external texture params buffer: {err:?}"),
-            })?;
-        self.default_external_texture_params_buffer
-            .set(params_buffer)
+        let mut staging_buffer =
+            StagingBuffer::new(self, wgt::BufferSize::new(size_of_val(&data) as _).unwrap())?;
+        staging_buffer.write(bytemuck::bytes_of(&data));
+        let staging_buffer = staging_buffer.flush();
+
+        let params_buffer = self.default_external_texture_params_buffer.as_ref();
+        let queue = self.get_queue().unwrap();
+        let mut pending_writes = queue.pending_writes.lock();
+
+        unsafe {
+            pending_writes
+                .command_encoder
+                .transition_buffers(&[hal::BufferBarrier {
+                    buffer: params_buffer,
+                    usage: hal::StateTransition {
+                        from: wgt::BufferUses::MAP_WRITE,
+                        to: wgt::BufferUses::COPY_SRC,
+                    },
+                }]);
+            pending_writes.command_encoder.copy_buffer_to_buffer(
+                staging_buffer.raw(),
+                params_buffer,
+                &[hal::BufferCopy {
+                    src_offset: 0,
+                    dst_offset: 0,
+                    size: staging_buffer.size,
+                }],
+            );
+            pending_writes.consume(staging_buffer);
+            pending_writes
+                .command_encoder
+                .transition_buffers(&[hal::BufferBarrier {
+                    buffer: params_buffer,
+                    usage: hal::StateTransition {
+                        from: wgt::BufferUses::COPY_DST,
+                        to: wgt::BufferUses::UNIFORM,
+                    },
+                }]);
+        }
+
+        Ok(())
+    }
+
+    pub fn late_init_resources_with_queue(self: &Arc<Self>) -> Result<(), RequestDeviceError> {
+        let queue = self.get_queue().unwrap();
+
+        let timestamp_normalizer = crate::timestamp_normalization::TimestampNormalizer::new(
+            self,
+            queue.get_timestamp_period(),
+        )?;
+
+        self.timestamp_normalizer
+            .set(timestamp_normalizer)
             .unwrap_or_else(|_| panic!("Called late_init_resources_with_queue twice"));
 
+        self.init_default_external_texture_params_buffer()?;
+
         Ok(())
     }
 
@@ -2669,11 +2714,7 @@ impl Device {
             },
         ];
         let params = hal::BufferBinding {
-            buffer: self
-                .default_external_texture_params_buffer
-                .get()
-                .expect("Default external texture params buffer should have been initialized")
-                .try_raw(snatch_guard)?,
+            buffer: self.default_external_texture_params_buffer.as_ref(),
             offset: 0,
             size: None,
         };