Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
perf(gpui): add streaming image patch that reuses one texture per stream, with backend tests and a CI job
Richie McIlroyf6c7a5a8b8bf
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.ymlindex 57810c005..f8ff8eb55 100644--- a/.github/workflows/ci.yml+++ b/.github/workflows/ci.yml@@ -24,6 +24,7 @@ jobs:rust: ${{ steps.filter.outputs.rust }}gpui: ${{ steps.filter.outputs.rust == 'true' || steps.filter.outputs.gpui == 'true' || steps.desktop-resources.outputs.desktop-resources == 'true' }}tauri-plugins: ${{ steps.filter.outputs.tauri-plugins }}+ gpui-patches: ${{ steps.filter.outputs.gpui-patches }}steps:- name: Checkoutuses: actions/checkout@v4@@ -65,6 +66,9 @@ jobs:- 'scripts/sync-desktop-versions.mjs'- 'scripts/verify-gpui-release-inputs.mjs'- 'scripts/verify-windows-stack.mjs'+ gpui-patches:+ - 'apps/desktop-gpui/patches/**'+ - 'scripts/prepare-gpui-dependency.sh'tauri-plugins:- 'Cargo.lock'- 'bun.lock'@@ -370,6 +374,65 @@ jobs:ficargo +1.95.0 test --manifest-path apps/desktop-gpui/Cargo.toml --locked --target ${{ matrix.settings.target }} -p cap-gpui-kernels+ # Cap only builds gpui's crates as dependencies, so their own tests never run+ # in the app jobs above. Run the ones covering Cap's patches against real+ # devices: Metal on macOS, WARP on Windows, and Mesa's lavapipe (Vulkan) and+ # llvmpipe (GL) on Linux. Zed's lockfile predates the patches' dependency+ # changes, so these builds cannot use --locked.+ gpui-patch-tests:+ name: GPUI patch tests (${{ matrix.settings.name }})+ needs: changes+ if: needs.changes.outputs.gpui-patches == 'true'+ timeout-minutes: 90+ strategy:+ fail-fast: false+ matrix:+ settings:+ - name: macOS+ runner: blacksmith-6vcpu-macos-15+ - name: Windows+ runner: blacksmith-8vcpu-windows-2025+ - name: Linux+ runner: blacksmith-8vcpu-ubuntu-2404+ runs-on: ${{ matrix.settings.runner }}+ env:+ CARGO_PROFILE_DEV_DEBUG: "0"+ steps:+ - name: Checkout repository+ uses: actions/checkout@v4++ - name: Install Linux desktop dependencies+ if: ${{ runner.os == 'Linux' }}+ uses: ./.github/actions/install-desktop-deps++ - name: Install software GPU drivers+ if: ${{ runner.os == 'Linux' }}+ run: sudo apt-get install -y --no-install-recommends mesa-vulkan-drivers libvulkan1 libegl1 libegl-mesa0 libgl1-mesa-dri++ - name: Rust setup+ uses: dtolnay/[email protected]++ - name: Prepare GPUI dependency+ shell: bash+ run: ./scripts/prepare-gpui-dependency.sh++ - name: Test GPUI patches+ shell: bash+ working-directory: ../zed-cap+ run: |+ cargo +1.95.0 test -p gpui --lib stream+ if [[ "$RUNNER_OS" == "Linux" ]]; then+ WGPU_BACKEND=vulkan cargo +1.95.0 test -p gpui_wgpu --lib wgpu_atlas -- --nocapture+ WGPU_BACKEND=gl cargo +1.95.0 test -p gpui_wgpu --lib wgpu_atlas -- --nocapture+ else+ cargo +1.95.0 test -p gpui_wgpu --lib wgpu_atlas -- --nocapture+ fi+ if [[ "$RUNNER_OS" == "macOS" ]]; then+ cargo +1.95.0 test -p gpui_macos --lib -- metal_atlas metal_renderer+ elif [[ "$RUNNER_OS" == "Windows" ]]; then+ cargo +1.95.0 test -p gpui_windows --lib directx_atlas+ fi+tauri-plugins:name: Verify Tauri plugin versionsruns-on: blacksmith-8vcpu-ubuntu-2404diff --git a/apps/desktop-gpui/patches/zed-streaming-image.patch b/apps/desktop-gpui/patches/zed-streaming-image.patchnew file mode 100644index 000000000..6d67d8333--- /dev/null+++ b/apps/desktop-gpui/patches/zed-streaming-image.patch@@ -0,0 +1,3049 @@+diff --git a/crates/gpui/src/gpui.rs b/crates/gpui/src/gpui.rs+index 4b1679c..a143fab 100644+--- a/crates/gpui/src/gpui.rs++++ b/crates/gpui/src/gpui.rs+@@ -47,6 +47,7 @@ pub mod profiler;+ pub mod queue;+ mod scene;+ mod shared_uri;++mod streaming_image;+ mod style;+ mod styled;+ mod subscription;+@@ -145,6 +146,7 @@ pub use refineable::*;+ pub use scene::*;+ pub use shared_uri::*;+ use std::{any::Any, future::Future};++pub use streaming_image::*;+ pub use style::*;+ pub use styled::*;+ pub use subscription::*;+diff --git a/crates/gpui/src/platform.rs b/crates/gpui/src/platform.rs+index 09adcdd..7dd2d38 100644+--- a/crates/gpui/src/platform.rs++++ b/crates/gpui/src/platform.rs+@@ -40,7 +40,8 @@ use crate::{+ FontRun, ForegroundExecutor, GlyphId, GpuSpecs, Hsla, ImageSource, Keymap, LineLayout, Pixels,+ PlatformGestures, PlatformInput, Point, Priority, RenderGlyphParams, RenderImage,+ RenderImageParams, RenderSvgParams, Scene, ShapedGlyph, ShapedRun, SharedString, Size,+- SvgRenderer, SystemWindowTab, Task, Window, WindowControlArea, hash, point, px, size,++ StreamFrame, StreamingImageId, SvgRenderer, SystemWindowTab, Task, Window, WindowControlArea,++ hash, point, px, size,+ };+ #[cfg(any(target_os = "linux", target_os = "freebsd"))]+ use anyhow::bail;+@@ -1316,6 +1317,17 @@ pub trait PlatformAtlas {+ build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,+ ) -> Result<Option<AtlasTile>>;+ fn remove(&self, key: &AtlasKey);++ /// Returns the tile of the texture that holds `frame` for the streaming++ /// image `id`, uploading the frame first when its generation differs from++ /// the one the texture holds. Stream textures are never packed with, or++ /// evicted alongside, atlas tiles.++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> Result<Option<AtlasTile>>;++ /// Releases the texture of the streaming image `id`, if there is one.++ fn remove_stream(&self, id: StreamingImageId);+ }++ #[doc(hidden)]+@@ -1368,6 +1380,24 @@ pub struct AtlasTile {+ pub bounds: Bounds<DevicePixels>,+ }+++impl AtlasTile {++ /// The tile covering the whole texture of a streaming image.++ pub fn for_stream(index: u32, size: Size<DevicePixels>) -> Self {++ Self {++ texture_id: AtlasTextureId {++ index,++ kind: AtlasTextureKind::Stream,++ },++ tile_id: TileId(0),++ padding: 0,++ bounds: Bounds {++ origin: Point::default(),++ size,++ },++ }++ }++}+++ #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]+ #[repr(C)]+ #[expect(missing_docs)]+@@ -1393,6 +1423,7 @@ pub enum AtlasTextureKind {+ Monochrome = 0,+ Polychrome = 1,+ Subpixel = 2,++ Stream = 3,+ }++ #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]+diff --git a/crates/gpui/src/platform/test/window.rs b/crates/gpui/src/platform/test/window.rs+index 8894350..562ec92 100644+--- a/crates/gpui/src/platform/test/window.rs++++ b/crates/gpui/src/platform/test/window.rs+@@ -2,8 +2,9 @@ use crate::{+ AnyWindowHandle, AtlasKey, AtlasTextureId, AtlasTile, Bounds, DevicePixels,+ DispatchEventResult, GpuSpecs, Pixels, PlatformAtlas, PlatformDisplay,+ PlatformHeadlessRenderer, PlatformInput, PlatformInputHandler, PlatformWindow, Point,+- PromptButton, RequestFrameOptions, Scene, Size, TestPlatform, TileId, WindowAppearance,+- WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowParams,++ PromptButton, RequestFrameOptions, Scene, Size, StreamFrame, StreamingImageId, TestPlatform,++ TileId, WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControlArea,++ WindowParams,+ };+ use collections::HashMap;+ use gpui_util::ResultExt as _;+@@ -345,6 +346,9 @@ impl PlatformWindow for TestWindow {+ pub(crate) struct TestAtlasState {+ next_id: u32,+ tiles: HashMap<AtlasKey, AtlasTile>,++ streams: HashMap<StreamingImageId, (u64, AtlasTile)>,++ stream_uploads: usize,++ removed_streams: Vec<StreamingImageId>,+ }++ pub(crate) struct TestAtlas(Mutex<TestAtlasState>);+@@ -354,8 +358,21 @@ impl TestAtlas {+ TestAtlas(Mutex::new(TestAtlasState {+ next_id: 0,+ tiles: HashMap::default(),++ streams: HashMap::default(),++ stream_uploads: 0,++ removed_streams: Vec::new(),+ }))+ }++++ #[cfg(test)]++ pub(crate) fn stream_uploads(&self) -> usize {++ self.0.lock().stream_uploads++ }++++ #[cfg(test)]++ pub(crate) fn removed_streams(&self) -> Vec<StreamingImageId> {++ self.0.lock().removed_streams.clone()++ }+ }++ impl PlatformAtlas for TestAtlas {+@@ -405,4 +422,35 @@ impl PlatformAtlas for TestAtlas {+ let mut state = self.0.lock();+ state.tiles.remove(key);+ }++++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> anyhow::Result<Option<AtlasTile>> {++ let mut state = self.0.lock();++ let state = &mut *state;++ if let Some((generation, tile)) = state.streams.get_mut(&id)++ && tile.bounds.size == frame.size()++ {++ let tile = *tile;++ if *generation != frame.generation() {++ *generation = frame.generation();++ state.stream_uploads += 1;++ }++ return Ok(Some(tile));++ }++ state.next_id += 1;++ let tile = AtlasTile::for_stream(state.next_id, frame.size());++ state.streams.insert(id, (frame.generation(), tile));++ state.stream_uploads += 1;++ Ok(Some(tile))++ }++++ fn remove_stream(&self, id: StreamingImageId) {++ let mut state = self.0.lock();++ if state.streams.remove(&id).is_some() {++ state.removed_streams.push(id);++ }++ }+ }+diff --git a/crates/gpui/src/streaming_image.rs b/crates/gpui/src/streaming_image.rs+new file mode 100644+index 0000000..3cb3416+--- /dev/null++++ b/crates/gpui/src/streaming_image.rs+@@ -0,0 +1,363 @@++use crate::{DevicePixels, Size};++use anyhow::{Context as _, Result};++use parking_lot::Mutex;++use std::{++ fmt,++ sync::{++ Arc, Weak,++ atomic::{AtomicU64, Ordering},++ },++};++++/// Identifies a [`StreamingImage`] for the lifetime of the process.++#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]++pub struct StreamingImageId(pub u64);++++/// The byte order of a [`StreamingImage`]'s pixels.++#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]++pub enum StreamingImageFormat {++ /// Blue, green, red, alpha, the order [`RenderImage`](crate::RenderImage) uses.++ Bgra8,++ /// Red, green, blue, alpha.++ Rgba8,++}++++/// One frame of a [`StreamingImage`], as returned by [`StreamingImage::current`].++#[derive(Clone)]++pub struct StreamFrame {++ generation: u64,++ size: Size<DevicePixels>,++ stride: usize,++ format: StreamingImageFormat,++ bytes: Arc<Vec<u8>>,++}++++impl StreamFrame {++ /// Increases every time the image receives a new frame.++ pub fn generation(&self) -> u64 {++ self.generation++ }++++ /// The frame's size in pixels.++ pub fn size(&self) -> Size<DevicePixels> {++ self.size++ }++++ /// The number of bytes from the start of one row to the start of the next.++ pub fn stride(&self) -> usize {++ self.stride++ }++++ /// The byte order of the frame's pixels.++ pub fn format(&self) -> StreamingImageFormat {++ self.format++ }++++ /// The frame's rows, [`Self::stride`] bytes apart. Holds at least++ /// `stride * height` bytes.++ pub fn bytes(&self) -> &[u8] {++ &self.bytes++ }++}++++impl fmt::Debug for StreamFrame {++ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {++ f.debug_struct("StreamFrame")++ .field("generation", &self.generation)++ .field("size", &self.size)++ .field("stride", &self.stride)++ .field("format", &self.format)++ .field("len", &self.bytes.len())++ .finish()++ }++}++++/// An image whose pixels are replaced frame after frame, such as a video or a++/// camera preview.++///++/// Each window that paints the image keeps one texture for it and uploads into++/// that texture only when the frame has changed, instead of packing every frame++/// into the sprite atlas as a new image. The texture is released once every++/// handle is dropped or the image is [cleared](Self::clear).++///++/// Handles are cheap to clone and frames can be set from any thread.++#[derive(Clone)]++pub struct StreamingImage(Arc<Shared>);++++struct Shared {++ id: StreamingImageId,++ format: StreamingImageFormat,++ state: Mutex<State>,++}++++#[derive(Default)]++struct State {++ generation: u64,++ frame: Option<StreamFrame>,++ spare: Option<Vec<u8>>,++}++++impl StreamingImage {++ /// Creates an image with no frame, whose frames are in the given byte order.++ pub fn new(format: StreamingImageFormat) -> Self {++ static NEXT_ID: AtomicU64 = AtomicU64::new(0);++ Self(Arc::new(Shared {++ id: StreamingImageId(NEXT_ID.fetch_add(1, Ordering::Relaxed)),++ format,++ state: Mutex::default(),++ }))++ }++++ /// The image's process-wide identifier.++ pub fn id(&self) -> StreamingImageId {++ self.0.id++ }++++ /// The byte order of the image's frames.++ pub fn format(&self) -> StreamingImageFormat {++ self.0.format++ }++++ /// Replaces the current frame with `bytes`, whose rows are `stride` bytes++ /// apart.++ ///++ /// Returns the previous frame's buffer when nothing else holds it any more,++ /// so the producer can write the next frame into it instead of allocating.++ pub fn set_frame(++ &self,++ size: Size<DevicePixels>,++ stride: usize,++ bytes: Vec<u8>,++ ) -> Result<Option<Vec<u8>>> {++ validate_frame(size, stride, bytes.len())?;++ let previous = self.replace_frame(size, stride, bytes);++ Ok(previous.and_then(|frame| Arc::try_unwrap(frame.bytes).ok()))++ }++++ /// Copies `bytes`, whose rows are `stride` bytes apart, into a new current++ /// frame. The copy reuses the buffer of an earlier frame once nothing else++ /// holds it, so a steady stream of same-sized frames does not allocate.++ pub fn copy_frame(&self, size: Size<DevicePixels>, stride: usize, bytes: &[u8]) -> Result<()> {++ validate_frame(size, stride, bytes.len())?;++ let len = stride * size.height.0 as usize;++ let mut buffer = self.0.state.lock().spare.take().unwrap_or_default();++ buffer.clear();++ buffer.extend_from_slice(&bytes[..len]);++ let previous = self.replace_frame(size, stride, buffer);++ if let Some(previous) = previous.and_then(|frame| Arc::try_unwrap(frame.bytes).ok()) {++ let mut state = self.0.state.lock();++ if state.frame.is_some() {++ state.spare = Some(previous);++ }++ }++ Ok(())++ }++++ /// The current frame, if any.++ pub fn current(&self) -> Option<StreamFrame> {++ self.0.state.lock().frame.clone()++ }++++ /// Drops the current frame. Windows stop painting the image and release++ /// its texture on their next draw.++ pub fn clear(&self) {++ let mut state = self.0.state.lock();++ state.frame = None;++ state.spare = None;++ }++++ pub(crate) fn downgrade(&self) -> WeakStreamingImage {++ WeakStreamingImage(Arc::downgrade(&self.0))++ }++++ fn replace_frame(++ &self,++ size: Size<DevicePixels>,++ stride: usize,++ bytes: Vec<u8>,++ ) -> Option<StreamFrame> {++ let mut state = self.0.state.lock();++ state.generation += 1;++ let frame = StreamFrame {++ generation: state.generation,++ size,++ stride,++ format: self.0.format,++ bytes: Arc::new(bytes),++ };++ state.frame.replace(frame)++ }++}++++impl fmt::Debug for StreamingImage {++ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {++ f.debug_struct("StreamingImage")++ .field("id", &self.0.id)++ .field("format", &self.0.format)++ .finish_non_exhaustive()++ }++}++++pub(crate) struct WeakStreamingImage(Weak<Shared>);++++impl WeakStreamingImage {++ pub(crate) fn has_frame(&self) -> bool {++ self.0++ .upgrade()++ .is_some_and(|shared| shared.state.lock().frame.is_some())++ }++}++++fn validate_frame(size: Size<DevicePixels>, stride: usize, len: usize) -> Result<()> {++ anyhow::ensure!(++ size.width.0 > 0 && size.height.0 > 0,++ "streaming image frames must not be empty, got {}x{}",++ size.width.0,++ size.height.0++ );++ let row_bytes = size.width.0 as usize * 4;++ anyhow::ensure!(++ stride >= row_bytes && stride.is_multiple_of(4),++ "stride {stride} must be a multiple of 4 and at least {row_bytes} for a frame {} pixels wide",++ size.width.0++ );++ let required = stride++ .checked_mul(size.height.0 as usize)++ .context("streaming image frame is too large")?;++ anyhow::ensure!(++ len >= required,++ "a {}x{} frame with stride {stride} needs {required} bytes, got {len}",++ size.width.0,++ size.height.0++ );++ Ok(())++}++++#[cfg(test)]++mod tests {++ use super::*;++ use crate::size;++++ fn frame_size(width: i32, height: i32) -> Size<DevicePixels> {++ size(DevicePixels(width), DevicePixels(height))++ }++++ #[test]++ fn handles_are_send_and_sync() {++ fn assert_send_sync<T: Send + Sync>() {}++ assert_send_sync::<StreamingImage>();++ assert_send_sync::<StreamFrame>();++ }++++ #[test]++ fn ids_are_unique() {++ let first = StreamingImage::new(StreamingImageFormat::Bgra8);++ let second = StreamingImage::new(StreamingImageFormat::Bgra8);++ assert_ne!(first.id(), second.id());++ assert_eq!(first.clone().id(), first.id());++ }++++ #[test]++ fn each_frame_advances_the_generation() {++ let image = StreamingImage::new(StreamingImageFormat::Rgba8);++ assert!(image.current().is_none());++++ image.set_frame(frame_size(2, 1), 8, vec![1; 8]).unwrap();++ let first = image.current().unwrap();++ assert_eq!(first.generation(), 1);++ assert_eq!(first.size(), frame_size(2, 1));++ assert_eq!(first.stride(), 8);++ assert_eq!(first.format(), StreamingImageFormat::Rgba8);++ assert_eq!(first.bytes(), &[1; 8]);++++ image.copy_frame(frame_size(1, 2), 4, &[2; 8]).unwrap();++ let second = image.current().unwrap();++ assert_eq!(second.generation(), 2);++ assert_eq!(second.size(), frame_size(1, 2));++ assert_eq!(second.bytes(), &[2; 8]);++ assert_eq!(first.bytes(), &[1; 8]);++ }++++ #[test]++ fn set_frame_returns_the_previous_buffer_once_nothing_holds_it() {++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ assert_eq!(++ image.set_frame(frame_size(1, 1), 4, vec![1; 4]).unwrap(),++ None++ );++++ let returned = image.set_frame(frame_size(1, 1), 4, vec![2; 4]).unwrap();++ assert_eq!(returned, Some(vec![1; 4]));++++ let held = image.current().unwrap();++ let returned = image.set_frame(frame_size(1, 1), 4, vec![3; 4]).unwrap();++ assert_eq!(returned, None);++ assert_eq!(held.bytes(), &[2; 4]);++ }++++ #[test]++ fn copy_frame_reuses_earlier_buffers() {++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let pixels = vec![7u8; 64 * 64 * 4];++ image.copy_frame(frame_size(64, 64), 256, &pixels).unwrap();++ let first = image.current().unwrap().bytes().as_ptr();++ image.copy_frame(frame_size(64, 64), 256, &pixels).unwrap();++ let second = image.current().unwrap().bytes().as_ptr();++ image.copy_frame(frame_size(64, 64), 256, &pixels).unwrap();++ let third = image.current().unwrap().bytes().as_ptr();++++ assert_ne!(first, second);++ assert_eq!(first, third);++ }++++ #[test]++ fn copy_frame_copies_whole_padded_rows() {++ let image = StreamingImage::new(StreamingImageFormat::Rgba8);++ let bytes: Vec<u8> = (0..40).collect();++ image.copy_frame(frame_size(1, 2), 16, &bytes).unwrap();++ assert_eq!(image.current().unwrap().bytes(), &bytes[..32]);++ }++++ #[test]++ fn invalid_frames_are_rejected_without_changing_the_image() {++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ image.set_frame(frame_size(2, 2), 8, vec![0; 16]).unwrap();++++ assert!(image.set_frame(frame_size(0, 2), 8, vec![0; 16]).is_err());++ assert!(image.set_frame(frame_size(2, 0), 8, vec![0; 16]).is_err());++ assert!(image.set_frame(frame_size(2, 2), 4, vec![0; 16]).is_err());++ assert!(image.set_frame(frame_size(2, 2), 10, vec![0; 20]).is_err());++ assert!(image.set_frame(frame_size(2, 2), 8, vec![0; 15]).is_err());++ assert!(image.copy_frame(frame_size(2, 2), 12, &[0; 20]).is_err());++ assert!(++ image++ .copy_frame(frame_size(i32::MAX, i32::MAX), usize::MAX - 3, &[])++ .is_err()++ );++++ let current = image.current().unwrap();++ assert_eq!(current.generation(), 1);++ assert_eq!(current.size(), frame_size(2, 2));++ }++++ #[test]++ fn clear_drops_the_frame_and_later_frames_keep_counting() {++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let weak = image.downgrade();++ assert!(!weak.has_frame());++++ image.set_frame(frame_size(1, 1), 4, vec![0; 4]).unwrap();++ assert!(weak.has_frame());++++ image.clear();++ assert!(image.current().is_none());++ assert!(!weak.has_frame());++++ image.copy_frame(frame_size(1, 1), 4, &[0; 4]).unwrap();++ assert_eq!(image.current().unwrap().generation(), 2);++ assert!(weak.has_frame());++++ drop(image);++ assert!(!weak.has_frame());++ }++}+diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rs+index de95b7d..75c3539 100644+--- a/crates/gpui/src/window.rs++++ b/crates/gpui/src/window.rs+@@ -21,6 +21,7 @@ use crate::{+ WindowOptions, WindowParams, WindowTextSystem, point, prelude::*, profiler, px, rems, size,+ transparent_black,+ };++use crate::{AtlasTile, StreamingImage, StreamingImageId, WeakStreamingImage};++ use anyhow::{Context as _, Result, anyhow};+ use collections::{FxHashMap, FxHashSet};+@@ -1102,6 +1103,7 @@ pub struct Window {+ pub(crate) platform_window: Box<dyn PlatformWindow>,+ display_id: Option<DisplayId>,+ sprite_atlas: Arc<dyn PlatformAtlas>,++ painted_streams: FxHashMap<StreamingImageId, WeakStreamingImage>,+ text_system: Arc<WindowTextSystem>,+ text_rendering_mode: Rc<Cell<TextRenderingMode>>,+ rem_size: Pixels,+@@ -1837,6 +1839,7 @@ impl Window {+ platform_window,+ display_id,+ sprite_atlas,++ painted_streams: FxHashMap::default(),+ text_system,+ text_rendering_mode: cx.text_rendering_mode.clone(),+ rem_size: px(16.),+@@ -2839,6 +2842,7 @@ impl Window {+ let _arena_scope = ElementArenaScope::enter(&cx.element_arena);++ self.invalidate_entities();++ self.release_unpainted_streams();+ cx.entities.clear_accessed();+ debug_assert!(self.rendered_entity_stack.is_empty());+ self.invalidator.set_dirty(false);+@@ -2967,6 +2971,17 @@ impl Window {+ mem::swap(&mut entities, entities_ref.deref_mut());+ }+++ fn release_unpainted_streams(&mut self) {++ let sprite_atlas = &self.sprite_atlas;++ self.painted_streams.retain(|id, image| {++ let keep = image.has_frame();++ if !keep {++ sprite_atlas.remove_stream(*id);++ }++ keep++ });++ }+++ fn invalidate_entities(&mut self) {+ let mut views = self.invalidator.take_views();+ for entity in views.drain() {+@@ -4587,8 +4602,6 @@ impl Window {+ ) -> Result<()> {+ self.invalidator.debug_assert_paint();++- let crop = (visible != fitted).then_some((visible, fitted));+- let bounds = self.snap_bounds(visible);+ let params = RenderImageParams {+ image_id: data.id,+ frame_index,+@@ -4606,6 +4619,66 @@ impl Window {+ )))+ })?+ .expect("Callback above only returns Some");++ self.insert_polychrome_tile(visible, fitted, corner_radii, tile, grayscale);++ Ok(())++ }++++ /// Paint the current frame of a [`StreamingImage`] into the scene for the++ /// next frame at the current z-index. Paints nothing while the image has++ /// no frame.++ ///++ /// The window uploads a frame at most once, however many elements paint++ /// it, and releases the image's texture once every handle to the image is++ /// dropped or the image is cleared.++ ///++ /// This method should only be called as part of the paint phase of element drawing.++ pub fn paint_streaming_image(++ &mut self,++ bounds: Bounds<Pixels>,++ corner_radii: Corners<Pixels>,++ image: &StreamingImage,++ grayscale: bool,++ ) -> Result<()> {++ self.paint_streaming_image_fitted(bounds, bounds, corner_radii, image, grayscale)++ }++++ /// [`Self::paint_streaming_image`] for object-fit layouts, with the same++ /// contract as [`Self::paint_image_fitted`].++ ///++ /// This method should only be called as part of the paint phase of element drawing.++ pub fn paint_streaming_image_fitted(++ &mut self,++ visible: Bounds<Pixels>,++ fitted: Bounds<Pixels>,++ corner_radii: Corners<Pixels>,++ image: &StreamingImage,++ grayscale: bool,++ ) -> Result<()> {++ self.invalidator.debug_assert_paint();++++ let Some(frame) = image.current() else {++ return Ok(());++ };++ self.painted_streams++ .entry(image.id())++ .or_insert_with(|| image.downgrade());++ let Some(tile) = self.sprite_atlas.get_or_update_stream(image.id(), &frame)? else {++ return Ok(());++ };++ self.insert_polychrome_tile(visible, fitted, corner_radii, tile, grayscale);++ Ok(())++ }++++ fn insert_polychrome_tile(++ &mut self,++ visible: Bounds<Pixels>,++ fitted: Bounds<Pixels>,++ corner_radii: Corners<Pixels>,++ tile: AtlasTile,++ grayscale: bool,++ ) {++ let crop = (visible != fitted).then_some((visible, fitted));++ let bounds = self.snap_bounds(visible);+ // Crop the atlas tile to the visible fraction of the fitted box+ // (proportional UV mapping; ≤1px rounding on arbitrary crops).+ let tile = match crop {+@@ -4646,7 +4719,6 @@ impl Window {+ tile,+ opacity,+ });+- Ok(())+ }++ /// Paint a surface into the scene for the next frame at the current z-index.+@@ -6990,11 +7062,12 @@ mod frame_pacer_tests {+ #[cfg(test)]+ mod tests {+ use crate::{+- AppContext as _, Bounds, Context, FocusHandle, InteractiveElement as _, IntoElement,+- ParentElement as _, Pixels, Render, Styled as _, TestAppContext, Window, canvas, div, px,+- size,++ AppContext as _, Bounds, Context, Corners, DevicePixels, FocusHandle,++ InteractiveElement as _, IntoElement, ParentElement as _, Pixels, PlatformAtlas, Render,++ StreamingImage, StreamingImageFormat, Styled as _, TestAppContext, Window, canvas, div,++ platform::TestAtlas, px, size,+ };+- use std::{cell::Cell, rc::Rc};++ use std::{cell::Cell, rc::Rc, sync::Arc};++ struct RootView {+ explicit_size: bool,+@@ -7075,6 +7148,77 @@ mod tests {+ }+ }+++ struct StreamView {++ images: Vec<StreamingImage>,++ }++++ impl Render for StreamView {++ fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {++ let images = self.images.clone();++ canvas(++ |_, _, _| {},++ move |bounds, _, window, _| {++ for image in &images {++ window++ .paint_streaming_image(bounds, Corners::default(), image, false)++ .unwrap();++ }++ },++ )++ .size_full()++ }++ }++++ #[test]++ fn streams_upload_once_per_generation_and_are_released_when_unreachable() {++ let mut cx = TestAppContext::single();++ let frame_size = size(DevicePixels(2), DevicePixels(2));++ let first = StreamingImage::new(StreamingImageFormat::Bgra8);++ let second = StreamingImage::new(StreamingImageFormat::Rgba8);++ first.set_frame(frame_size, 8, vec![0; 16]).unwrap();++ second.set_frame(frame_size, 8, vec![0; 16]).unwrap();++ let window = cx.add_window({++ let images = vec![first.clone(), first.clone(), second.clone()];++ move |_, _| StreamView { images }++ });++ let atlas = Arc::new(TestAtlas::new());++ cx.update_window(window.into(), |_, window, _| {++ window.sprite_atlas = atlas.clone() as Arc<dyn PlatformAtlas>;++ })++ .unwrap();++ let draw = |cx: &mut TestAppContext| {++ cx.update_window(window.into(), |_, window, cx| {++ window.draw(cx).clear();++ window.painted_streams.len()++ })++ .unwrap()++ };++++ assert_eq!(draw(&mut cx), 2);++ assert_eq!(atlas.stream_uploads(), 2);++ assert_eq!(draw(&mut cx), 2);++ assert_eq!(atlas.stream_uploads(), 2);++++ first.set_frame(frame_size, 8, vec![1; 16]).unwrap();++ assert_eq!(draw(&mut cx), 2);++ assert_eq!(atlas.stream_uploads(), 3);++ assert!(atlas.removed_streams().is_empty());++++ second.clear();++ assert_eq!(draw(&mut cx), 1);++ assert_eq!(atlas.removed_streams(), vec![second.id()]);++++ window++ .update(&mut cx, |view, _, _| view.images.clear())++ .unwrap();++ let first_id = first.id();++ drop(first);++ assert_eq!(draw(&mut cx), 0);++ assert_eq!(atlas.removed_streams(), vec![second.id(), first_id]);++ assert_eq!(draw(&mut cx), 0);++ assert_eq!(atlas.removed_streams().len(), 2);++ }+++ /// When a focus listener moves focus again (e.g. a dock forwarding focus to its+ /// active panel), the resulting focus events must be dispatched without waiting+ /// for an unrelated redraw of the window.+diff --git a/crates/gpui_linux/src/linux/headless/window.rs b/crates/gpui_linux/src/linux/headless/window.rs+index e41b097..dac72f9 100644+--- a/crates/gpui_linux/src/linux/headless/window.rs++++ b/crates/gpui_linux/src/linux/headless/window.rs+@@ -18,8 +18,8 @@ use gpui::{+ AtlasKey, AtlasTextureId, AtlasTile, Bounds, Capslock, DevicePixels, DispatchEventResult,+ DisplayId, GpuSpecs, Modifiers, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,+ PlatformInputHandler, PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions,+- Scene, Size, TileId, WindowAppearance, WindowBackgroundAppearance, WindowBounds,+- WindowControlArea, WindowParams, px,++ Scene, Size, StreamFrame, StreamingImageId, TileId, WindowAppearance,++ WindowBackgroundAppearance, WindowBounds, WindowControlArea, WindowParams, px,+ };++ #[derive(Debug)]+@@ -239,6 +239,7 @@ struct HeadlessAtlas(Mutex<HeadlessAtlasState>);+ struct HeadlessAtlasState {+ next_id: u32,+ tiles: HashMap<AtlasKey, AtlasTile>,++ streams: HashMap<StreamingImageId, AtlasTile>,+ }++ impl PlatformAtlas for HeadlessAtlas {+@@ -284,4 +285,25 @@ impl PlatformAtlas for HeadlessAtlas {+ fn remove(&self, key: &AtlasKey) {+ self.0.lock().tiles.remove(key);+ }++++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> anyhow::Result<Option<AtlasTile>> {++ let mut state = self.0.lock();++ if let Some(tile) = state.streams.get(&id)++ && tile.bounds.size == frame.size()++ {++ return Ok(Some(*tile));++ }++ state.next_id += 1;++ let tile = AtlasTile::for_stream(state.next_id, frame.size());++ state.streams.insert(id, tile);++ Ok(Some(tile))++ }++++ fn remove_stream(&self, id: StreamingImageId) {++ self.0.lock().streams.remove(&id);++ }+ }+diff --git a/crates/gpui_macos/src/metal_atlas.rs b/crates/gpui_macos/src/metal_atlas.rs+index d007abb..f418f88 100644+--- a/crates/gpui_macos/src/metal_atlas.rs++++ b/crates/gpui_macos/src/metal_atlas.rs+@@ -4,11 +4,21 @@ use derive_more::{Deref, DerefMut};+ use etagere::BucketedAtlasAllocator;+ use gpui::{+ AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTextureList, AtlasTile, Bounds, DevicePixels,+- PlatformAtlas, Point, Size,++ PlatformAtlas, Point, Size, StreamFrame, StreamingImageFormat, StreamingImageId,+ };+ use metal::Device;+ use parking_lot::Mutex;+-use std::borrow::Cow;++use std::{++ borrow::Cow,++ sync::{++ Arc,++ atomic::{AtomicU32, Ordering},++ },++};++++const MAX_STREAM_TEXTURE_SIZE: i32 = 16384;++const SINGLE_SLOT_STREAM_BYTES: u64 = 32 * 1024 * 1024;++const SPARE_SLOT_RELEASE_UPLOADS: u32 = 120;++ pub(crate) struct MetalAtlas(Mutex<MetalAtlasState>);++@@ -20,9 +30,44 @@ impl MetalAtlas {+ monochrome_textures: Default::default(),+ polychrome_textures: Default::default(),+ tiles_by_key: Default::default(),++ streams: Vec::new(),++ next_stream_index: 0,++ stream_textures_created: 0,+ }))+ }+++ /// The texture a stream sprite batch should sample, plus a lease that keeps++ /// later uploads out of that texture until the GPU is done with it. `None`++ /// once the stream has been removed.++ pub(crate) fn lease_stream_texture(++ &self,++ id: AtlasTextureId,++ ) -> Option<(metal::Texture, MetalStreamLease)> {++ let lock = self.0.lock();++ let stream = lock++ .streams++ .iter()++ .find(|stream| stream.index == id.index)?;++ let slot = stream.slots.get(stream.front)?;++ Some((++ slot.texture.0.clone(),++ MetalStreamLease::new(&slot.in_flight),++ ))++ }++++ /// (live stream textures, their total bytes, stream textures created so++ /// far) for COMET_GPU_STATS.++ pub(crate) fn stream_stats(&self) -> (usize, u64, u64) {++ let lock = self.0.lock();++ let mut count = 0;++ let mut bytes = 0;++ for slot in lock.streams.iter().flat_map(|stream| &stream.slots) {++ count += 1;++ bytes += slot.texture.width() * slot.texture.height() * 4;++ }++ (count, bytes, lock.stream_textures_created)++ }+++ pub(crate) fn metal_texture(&self, id: AtlasTextureId) -> metal::Texture {+ self.0.lock().texture(id).metal_texture.clone()+ }+@@ -54,6 +99,9 @@ struct MetalAtlasState {+ monochrome_textures: AtlasTextureList<MetalAtlasTexture>,+ polychrome_textures: AtlasTextureList<MetalAtlasTexture>,+ tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,++ streams: Vec<MetalAtlasStream>,++ next_stream_index: u32,++ stream_textures_created: u64,+ }++ impl PlatformAtlas for MetalAtlas {+@@ -89,7 +137,7 @@ impl PlatformAtlas for MetalAtlas {+ let textures = match id.kind {+ AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,+- AtlasTextureKind::Subpixel => unreachable!(),++ AtlasTextureKind::Subpixel | AtlasTextureKind::Stream => unreachable!(),+ };++ let Some(texture_slot) = textures+@@ -110,6 +158,18 @@ impl PlatformAtlas for MetalAtlas {+ }+ }+ }++++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> Result<Option<AtlasTile>> {++ self.0.lock().update_stream(id, frame).map(Some)++ }++++ fn remove_stream(&self, id: StreamingImageId) {++ self.0.lock().streams.retain(|stream| stream.id != id);++ }+ }++ impl MetalAtlasState {+@@ -122,7 +182,7 @@ impl MetalAtlasState {+ let textures = match texture_kind {+ AtlasTextureKind::Monochrome => &mut self.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut self.polychrome_textures,+- AtlasTextureKind::Subpixel => unreachable!(),++ AtlasTextureKind::Subpixel | AtlasTextureKind::Stream => unreachable!(),+ };++ if let Some(tile) = textures+@@ -167,7 +227,7 @@ impl MetalAtlasState {+ pixel_format = metal::MTLPixelFormat::BGRA8Unorm;+ usage = metal::MTLTextureUsage::ShaderRead;+ }+- AtlasTextureKind::Subpixel => unreachable!(),++ AtlasTextureKind::Subpixel | AtlasTextureKind::Stream => unreachable!(),+ }+ texture_descriptor.set_pixel_format(pixel_format);+ texture_descriptor.set_usage(usage);+@@ -183,7 +243,7 @@ impl MetalAtlasState {+ let texture_list = match kind {+ AtlasTextureKind::Monochrome => &mut self.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut self.polychrome_textures,+- AtlasTextureKind::Subpixel => unreachable!(),++ AtlasTextureKind::Subpixel | AtlasTextureKind::Stream => unreachable!(),+ };++ let index = texture_list.free_list.pop();+@@ -214,10 +274,173 @@ impl MetalAtlasState {+ let textures = match id.kind {+ AtlasTextureKind::Monochrome => &self.monochrome_textures,+ AtlasTextureKind::Polychrome => &self.polychrome_textures,+- AtlasTextureKind::Subpixel => unreachable!(),++ AtlasTextureKind::Subpixel | AtlasTextureKind::Stream => unreachable!(),+ };+ textures[id.index as usize].as_ref().unwrap()+ }++++ fn update_stream(&mut self, id: StreamingImageId, frame: &StreamFrame) -> Result<AtlasTile> {++ let size = frame.size();++ anyhow::ensure!(++ size.width.0 <= MAX_STREAM_TEXTURE_SIZE && size.height.0 <= MAX_STREAM_TEXTURE_SIZE,++ "streaming image frame {}x{} exceeds the {MAX_STREAM_TEXTURE_SIZE} pixel texture limit",++ size.width.0,++ size.height.0++ );++ let pixel_format = match frame.format() {++ StreamingImageFormat::Bgra8 => metal::MTLPixelFormat::BGRA8Unorm,++ StreamingImageFormat::Rgba8 => metal::MTLPixelFormat::RGBA8Unorm,++ };++ let position = match self.streams.iter().position(|stream| stream.id == id) {++ Some(position) => {++ let stream = &mut self.streams[position];++ if stream.size != size || stream.pixel_format != pixel_format {++ *stream = MetalAtlasStream::new(id, stream.index, size, pixel_format);++ }++ position++ }++ None => {++ let index = self.next_stream_index;++ self.next_stream_index = self.next_stream_index.wrapping_add(1);++ self.streams++ .push(MetalAtlasStream::new(id, index, size, pixel_format));++ self.streams.len() - 1++ }++ };++ let stream = &mut self.streams[position];++ if stream.slots.is_empty() || stream.generation != frame.generation() {++ let created = stream.upload(&self.device, self.is_apple_gpu, frame);++ self.stream_textures_created += created as u64;++ }++ Ok(AtlasTile::for_stream(stream.index, size))++ }++}++++/// A streaming image's textures. Frames go into a slot the GPU is not reading;++/// a second slot exists only while uploads keep finding the current one busy.++struct MetalAtlasStream {++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ pixel_format: metal::MTLPixelFormat,++ generation: u64,++ slots: Vec<MetalStreamSlot>,++ front: usize,++ uncontended_uploads: u32,++}++++struct MetalStreamSlot {++ texture: AssertSend<metal::Texture>,++ in_flight: Arc<AtomicU32>,++}++++/// Marks a stream slot as read by a command buffer until dropped.++pub(crate) struct MetalStreamLease(Arc<AtomicU32>);++++impl MetalStreamLease {++ fn new(in_flight: &Arc<AtomicU32>) -> Self {++ in_flight.fetch_add(1, Ordering::AcqRel);++ Self(in_flight.clone())++ }++}++++impl Drop for MetalStreamLease {++ fn drop(&mut self) {++ self.0.fetch_sub(1, Ordering::AcqRel);++ }++}++++impl MetalAtlasStream {++ fn new(++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ pixel_format: metal::MTLPixelFormat,++ ) -> Self {++ Self {++ id,++ index,++ size,++ pixel_format,++ generation: 0,++ slots: Vec::new(),++ front: 0,++ uncontended_uploads: 0,++ }++ }++++ /// Writes `frame` into a slot no command buffer is reading and makes it++ /// the front slot, without ever waiting on the GPU. Returns how many++ /// textures it created.++ fn upload(++ &mut self,++ device: &metal::DeviceRef,++ is_apple_gpu: bool,++ frame: &StreamFrame,++ ) -> u32 {++ let frame_bytes = self.size.width.0 as u64 * self.size.height.0 as u64 * 4;++ let max_slots = if frame_bytes > SINGLE_SLOT_STREAM_BYTES {++ 1++ } else {++ 2++ };++ let is_free = |slot: &MetalStreamSlot| slot.in_flight.load(Ordering::Acquire) == 0;++ let mut created = 0;++ let target = if self.slots.get(self.front).is_some_and(is_free) {++ self.uncontended_uploads += 1;++ self.front++ } else {++ self.uncontended_uploads = 0;++ if let Some(index) = self.slots.iter().position(is_free) {++ index++ } else if self.slots.len() < max_slots {++ created += 1;++ self.slots.push(self.new_slot(device, is_apple_gpu));++ self.slots.len() - 1++ } else {++ created += 1;++ let index = (self.front + 1) % self.slots.len();++ self.slots[index] = self.new_slot(device, is_apple_gpu);++ index++ }++ };++++ let region =++ metal::MTLRegion::new_2d(0, 0, self.size.width.0 as u64, self.size.height.0 as u64);++ self.slots[target].texture.replace_region(++ region,++ 0,++ frame.bytes().as_ptr() as *const _,++ frame.stride() as u64,++ );++ self.front = target;++ self.generation = frame.generation();++++ if self.uncontended_uploads >= SPARE_SLOT_RELEASE_UPLOADS && self.slots.len() > 1 {++ self.slots.swap(0, self.front);++ self.slots.truncate(1);++ self.front = 0;++ self.uncontended_uploads = 0;++ }++ created++ }++++ fn new_slot(&self, device: &metal::DeviceRef, is_apple_gpu: bool) -> MetalStreamSlot {++ let descriptor = metal::TextureDescriptor::new();++ descriptor.set_width(self.size.width.0 as u64);++ descriptor.set_height(self.size.height.0 as u64);++ descriptor.set_pixel_format(self.pixel_format);++ descriptor.set_usage(metal::MTLTextureUsage::ShaderRead);++ descriptor.set_storage_mode(if is_apple_gpu {++ metal::MTLStorageMode::Shared++ } else {++ metal::MTLStorageMode::Managed++ });++ MetalStreamSlot {++ texture: AssertSend(device.new_texture(&descriptor)),++ in_flight: Arc::default(),++ }++ }+ }++ struct MetalAtlasTexture {+@@ -295,7 +518,7 @@ unsafe impl<T> Send for AssertSend<T> {}+ #[cfg(test)]+ mod tests {+ use super::*;+- use gpui::PlatformAtlas;++ use gpui::{PlatformAtlas, StreamingImage};+ use std::borrow::Cow;++ fn create_atlas() -> Option<MetalAtlas> {+@@ -396,4 +619,355 @@ mod tests {+ let key = make_image_key(999, 0);+ atlas.remove(&key);+ }++ fn stream_size(width: i32, height: i32) -> Size<DevicePixels> {++ Size {++ width: DevicePixels(width),++ height: DevicePixels(height),++ }++ }++++ fn set_stream_frame(++ image: &StreamingImage,++ size: Size<DevicePixels>,++ value: u8,++ ) -> StreamFrame {++ let stride = size.width.0 as usize * 4;++ image++ .set_frame(size, stride, vec![value; stride * size.height.0 as usize])++ .unwrap();++ image.current().unwrap()++ }++++ fn update_stream(atlas: &MetalAtlas, image: &StreamingImage, frame: &StreamFrame) -> AtlasTile {++ atlas++ .get_or_update_stream(image.id(), frame)++ .expect("stream upload should succeed")++ .expect("stream upload returns a tile")++ }++++ fn stream_slot_textures(atlas: &MetalAtlas, image: &StreamingImage) -> Vec<usize> {++ use metal::foreign_types::ForeignType as _;++ let lock = atlas.0.lock();++ let stream = lock++ .streams++ .iter()++ .find(|stream| stream.id == image.id())++ .expect("stream should exist");++ stream++ .slots++ .iter()++ .map(|slot| slot.texture.as_ptr() as usize)++ .collect()++ }++++ fn stream_textures_created(atlas: &MetalAtlas) -> u64 {++ atlas.0.lock().stream_textures_created++ }++++ fn read_texture(device: &metal::DeviceRef, texture: &metal::TextureRef) -> Vec<u8> {++ let queue = device.new_command_queue();++ let command_buffer = queue.new_command_buffer();++ let buffer = read_back_into_new_buffer(device, command_buffer, texture);++ command_buffer.commit();++ command_buffer.wait_until_completed();++ buffer_bytes(&buffer)++ }++++ fn read_back_into_new_buffer(++ device: &metal::DeviceRef,++ command_buffer: &metal::CommandBufferRef,++ texture: &metal::TextureRef,++ ) -> metal::Buffer {++ let row_bytes = texture.width() * 4;++ let len = row_bytes * texture.height();++ let buffer = device.new_buffer(len, metal::MTLResourceOptions::StorageModeShared);++ let blit = command_buffer.new_blit_command_encoder();++ blit.copy_from_texture_to_buffer(++ texture,++ 0,++ 0,++ metal::MTLOrigin { x: 0, y: 0, z: 0 },++ metal::MTLSize {++ width: texture.width(),++ height: texture.height(),++ depth: 1,++ },++ &buffer,++ 0,++ row_bytes,++ len,++ metal::MTLBlitOption::None,++ );++ blit.end_encoding();++ buffer++ }++++ fn buffer_bytes(buffer: &metal::BufferRef) -> Vec<u8> {++ unsafe {++ std::slice::from_raw_parts(buffer.contents() as *const u8, buffer.length() as usize)++ .to_vec()++ }++ }++++ #[test]++ fn stream_updates_of_the_same_size_reuse_one_texture() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(96, 54);++++ let first = update_stream(&atlas, &image, &set_stream_frame(&image, size, 1));++ let textures = stream_slot_textures(&atlas, &image);++ for value in 2..10 {++ let tile = update_stream(&atlas, &image, &set_stream_frame(&image, size, value));++ assert_eq!(tile, first);++ }++++ assert_eq!(first.texture_id.kind, AtlasTextureKind::Stream);++ assert_eq!(first.bounds.size, size);++ assert_eq!(stream_slot_textures(&atlas, &image), textures);++ assert_eq!(textures.len(), 1);++ assert_eq!(stream_textures_created(&atlas), 1);++ let (texture, _lease) = atlas.lease_stream_texture(first.texture_id).unwrap();++ assert!(++ read_texture(&atlas.0.lock().device, &texture)++ .iter()++ .all(|&byte| byte == 9)++ );++ }++++ #[test]++ fn stream_skips_upload_when_the_generation_is_unchanged() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(8, 8);++ let frame = set_stream_frame(&image, size, 1);++ let tile = update_stream(&atlas, &image, &frame);++ let (texture, _lease) = atlas.lease_stream_texture(tile.texture_id).unwrap();++ texture.replace_region(++ metal::MTLRegion::new_2d(0, 0, 8, 8),++ 0,++ vec![5u8; 8 * 8 * 4].as_ptr() as *const _,++ 32,++ );++++ assert_eq!(update_stream(&atlas, &image, &frame), tile);++ let device = atlas.0.lock().device.0.clone();++ assert!(++ read_texture(&device, &texture)++ .iter()++ .all(|&byte| byte == 5)++ );++ }++++ #[test]++ fn stream_size_change_reallocates_once() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let small = update_stream(++ &atlas,++ &image,++ &set_stream_frame(&image, stream_size(64, 36), 1),++ );++ let small_textures = stream_slot_textures(&atlas, &image);++++ let large_size = stream_size(128, 72);++ let large = update_stream(&atlas, &image, &set_stream_frame(&image, large_size, 2));++ let large_textures = stream_slot_textures(&atlas, &image);++ update_stream(&atlas, &image, &set_stream_frame(&image, large_size, 3));++++ assert_eq!(large.texture_id, small.texture_id);++ assert_eq!(large.bounds.size, large_size);++ assert_ne!(large_textures, small_textures);++ assert_eq!(stream_slot_textures(&atlas, &image), large_textures);++ assert_eq!(stream_textures_created(&atlas), 2);++ }++++ #[test]++ fn stream_format_change_reallocates() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let size = stream_size(16, 16);++ let bgra = StreamingImage::new(StreamingImageFormat::Bgra8);++ let rgba = StreamingImage::new(StreamingImageFormat::Rgba8);++ let bgra_tile = update_stream(&atlas, &bgra, &set_stream_frame(&bgra, size, 1));++ let rgba_tile = update_stream(&atlas, &rgba, &set_stream_frame(&rgba, size, 1));++++ let (bgra_texture, _) = atlas.lease_stream_texture(bgra_tile.texture_id).unwrap();++ let (rgba_texture, _) = atlas.lease_stream_texture(rgba_tile.texture_id).unwrap();++ assert_ne!(bgra_tile.texture_id, rgba_tile.texture_id);++ assert_eq!(++ bgra_texture.pixel_format(),++ metal::MTLPixelFormat::BGRA8Unorm++ );++ assert_eq!(++ rgba_texture.pixel_format(),++ metal::MTLPixelFormat::RGBA8Unorm++ );++ }++++ #[test]++ fn images_and_streams_never_share_textures() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let small = stream_size(64, 64);++ let image_key = make_image_key(1, 0);++ let image_tile = insert_tile(&atlas, &image_key, small);++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let stream_tile = update_stream(&atlas, &image, &set_stream_frame(&image, small, 1));++ let second_image_tile = insert_tile(&atlas, &make_image_key(2, 0), small);++++ assert_eq!(image_tile.texture_id.kind, AtlasTextureKind::Polychrome);++ assert_eq!(second_image_tile.texture_id, image_tile.texture_id);++ assert_eq!(stream_tile.texture_id.kind, AtlasTextureKind::Stream);++ assert_eq!(++ atlas++ .0++ .lock()++ .polychrome_textures++ .textures++ .iter()++ .flatten()++ .count(),++ 1++ );++++ atlas.remove(&image_key);++ assert!(atlas.lease_stream_texture(stream_tile.texture_id).is_some());++ atlas.remove_stream(image.id());++ assert!(atlas.lease_stream_texture(stream_tile.texture_id).is_none());++ let _texture = atlas.metal_texture(second_image_tile.texture_id);++ atlas.remove_stream(image.id());++ }++++ #[test]++ fn removed_streams_upload_again_with_a_fresh_texture_index() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let frame = set_stream_frame(&image, stream_size(8, 8), 1);++ let first = update_stream(&atlas, &image, &frame);++ atlas.remove_stream(image.id());++ let second = update_stream(&atlas, &image, &frame);++++ assert_ne!(first.texture_id, second.texture_id);++ assert!(atlas.lease_stream_texture(first.texture_id).is_none());++ assert!(atlas.lease_stream_texture(second.texture_id).is_some());++ assert_eq!(stream_textures_created(&atlas), 2);++ }++++ #[test]++ fn oversized_stream_frames_are_rejected() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(MAX_STREAM_TEXTURE_SIZE + 1, 1);++ let stride = size.width.0 as usize * 4;++ image.set_frame(size, stride, vec![0; stride]).unwrap();++ assert!(++ atlas++ .get_or_update_stream(image.id(), &image.current().unwrap())++ .is_err()++ );++ }++++ fn assert_upload_waits_for_no_reader(is_apple_gpu: bool) {++ let Some(device) = metal::Device::system_default() else {++ return;++ };++ let atlas = MetalAtlas::new(device.clone(), is_apple_gpu);++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 64);++ let tile = update_stream(&atlas, &image, &set_stream_frame(&image, size, 1));++++ let queue = device.new_command_queue();++ let command_buffer = queue.new_command_buffer();++ let (texture, lease) = atlas.lease_stream_texture(tile.texture_id).unwrap();++ let first_read = read_back_into_new_buffer(&device, command_buffer, &texture);++++ assert_eq!(++ update_stream(&atlas, &image, &set_stream_frame(&image, size, 2)),++ tile++ );++ command_buffer.commit();++ command_buffer.wait_until_completed();++ drop(lease);++++ assert!(buffer_bytes(&first_read).iter().all(|&byte| byte == 1));++ assert_eq!(stream_slot_textures(&atlas, &image).len(), 2);++ assert_eq!(stream_textures_created(&atlas), 2);++ let (texture, _lease) = atlas.lease_stream_texture(tile.texture_id).unwrap();++ assert!(++ read_texture(&device, &texture)++ .iter()++ .all(|&byte| byte == 2)++ );++++ update_stream(&atlas, &image, &set_stream_frame(&image, size, 3));++ assert_eq!(stream_textures_created(&atlas), 2);++ }++++ #[test]++ fn stream_upload_skips_a_slot_an_uncommitted_command_buffer_reads() {++ assert_upload_waits_for_no_reader(true);++ }++++ #[test]++ fn stream_upload_skips_a_slot_an_uncommitted_command_buffer_reads_managed() {++ assert_upload_waits_for_no_reader(false);++ }++++ #[test]++ fn stream_releases_its_spare_slot_once_uploads_stop_contending() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(32, 32);++ let tile = update_stream(&atlas, &image, &set_stream_frame(&image, size, 0));++ let lease = atlas.lease_stream_texture(tile.texture_id).unwrap();++ update_stream(&atlas, &image, &set_stream_frame(&image, size, 1));++ drop(lease);++ assert_eq!(stream_slot_textures(&atlas, &image).len(), 2);++++ for value in 0..SPARE_SLOT_RELEASE_UPLOADS {++ update_stream(&atlas, &image, &set_stream_frame(&image, size, value as u8));++ }++ assert_eq!(stream_slot_textures(&atlas, &image).len(), 1);++ let (texture, _lease) = atlas.lease_stream_texture(tile.texture_id).unwrap();++ let expected = (SPARE_SLOT_RELEASE_UPLOADS - 1) as u8;++ let device = atlas.0.lock().device.0.clone();++ assert!(++ read_texture(&device, &texture)++ .iter()++ .all(|&byte| byte == expected)++ );++ }++++ #[test]++ fn large_streams_keep_a_single_slot_and_never_block() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(3840, 2304);++ let tile = update_stream(&atlas, &image, &set_stream_frame(&image, size, 1));++ let (held, lease) = atlas.lease_stream_texture(tile.texture_id).unwrap();++++ update_stream(&atlas, &image, &set_stream_frame(&image, size, 2));++ assert_eq!(stream_slot_textures(&atlas, &image).len(), 1);++ assert_eq!(stream_textures_created(&atlas), 2);++ let device = atlas.0.lock().device.0.clone();++ assert!(read_texture(&device, &held).iter().all(|&byte| byte == 1));++ drop(lease);++ }+ }+diff --git a/crates/gpui_macos/src/metal_renderer.rs b/crates/gpui_macos/src/metal_renderer.rs+index 1d35af1..57afb61 100644+--- a/crates/gpui_macos/src/metal_renderer.rs++++ b/crates/gpui_macos/src/metal_renderer.rs+@@ -1,4 +1,4 @@+-use crate::metal_atlas::MetalAtlas;++use crate::metal_atlas::{MetalAtlas, MetalStreamLease};+ use anyhow::Result;+ use block::ConcreteBlock;+ use cocoa::{+@@ -7,9 +7,9 @@ use cocoa::{+ quartzcore::AutoresizingMask,+ };+ use gpui::{+- AtlasTextureId, BackdropBlur, Background, Bounds, ContentMask, Corners, DevicePixels,+- DrawOrder, MonochromeSprite, PaintSurface, Path, Point, PolychromeSprite, PrimitiveBatch, Quad,+- ScaledPixels, Scene, Shadow, Size, Underline, point, size,++ AtlasTextureId, AtlasTextureKind, BackdropBlur, Background, Bounds, ContentMask, Corners,++ DevicePixels, DrawOrder, MonochromeSprite, PaintSurface, Path, Point, PolychromeSprite,++ PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, Underline, point, size,+ };+ #[cfg(any(test, feature = "test-support"))]+ use image::RgbaImage;+@@ -928,6 +928,7 @@ impl MetalRenderer {+ let alpha = if self.opaque { 1. } else { 0. };+ let mut instance_offset = 0;+ let mut retained_surface_textures = CommandBufferResources::default();++ let mut retained_stream_leases = CommandBufferResources::default();++ // Big scratch textures are only worth holding while they're in use:+ // after a run of frames that don't need them, drop them and let the+@@ -1141,6 +1142,7 @@ impl MetalRenderer {+ &mut instance_offset,+ viewport_size,+ command_encoder,++ &mut retained_stream_leases,+ ),+ PrimitiveBatch::Surfaces(range) => self.draw_surfaces(+ &scene.surfaces[range],+@@ -1181,6 +1183,7 @@ impl MetalRenderer {+ self.maybe_log_gpu_stats();++ retained_surface_textures.retain_until_completion(command_buffer);++ retained_stream_leases.retain_until_completion(command_buffer);++ Ok(command_buffer.to_owned())+ }+@@ -1217,6 +1220,8 @@ impl MetalRenderer {+ 1+ };+ let (atlas_textures, atlas_bytes) = self.sprite_atlas.texture_stats();++ let (stream_textures, stream_bytes, stream_textures_created) =++ self.sprite_atlas.stream_stats();+ let (pool_buffers, pool_buffer_size) = {+ let pool = self.instance_buffer_pool.lock();+ (pool.buffers.len(), pool.buffer_size)+@@ -1224,7 +1229,7 @@ impl MetalRenderer {+ // stderr, not `log`: consumers (comet) run tracing without a log+ // bridge, and this line only exists when explicitly opted into.+ eprintln!(+- "[gpu-stats] device: {:.1} MB; atlas: {} textures, {:.1} MB; instance pool: {} × {:.1} MB; backdrop scratch: {:.1} MB; path intermediate: {:.1} MB",++ "[gpu-stats] device: {:.1} MB; atlas: {} textures, {:.1} MB; instance pool: {} × {:.1} MB; backdrop scratch: {:.1} MB; path intermediate: {:.1} MB; streams: {} textures, {:.1} MB, {} created",+ self.device.current_allocated_size() as f64 / (1024.0 * 1024.0),+ atlas_textures,+ atlas_bytes as f64 / (1024.0 * 1024.0),+@@ -1232,6 +1237,9 @@ impl MetalRenderer {+ pool_buffer_size as f64 / (1024.0 * 1024.0),+ backdrop_bytes as f64 / (1024.0 * 1024.0),+ path_bytes as f64 / (1024.0 * 1024.0),++ stream_textures,++ stream_bytes as f64 / (1024.0 * 1024.0),++ stream_textures_created,+ );+ }++@@ -1832,13 +1840,22 @@ impl MetalRenderer {+ instance_offset: &mut usize,+ viewport_size: Size<DevicePixels>,+ command_encoder: &metal::RenderCommandEncoderRef,++ retained_stream_leases: &mut CommandBufferResources<MetalStreamLease>,+ ) -> bool {+ if sprites.is_empty() {+ return true;+ }+ align_offset(instance_offset);++- let texture = self.sprite_atlas.metal_texture(texture_id);++ let texture = if texture_id.kind == AtlasTextureKind::Stream {++ let Some((texture, lease)) = self.sprite_atlas.lease_stream_texture(texture_id) else {++ return true;++ };++ retained_stream_leases.push(lease);++ texture++ } else {++ self.sprite_atlas.metal_texture(texture_id)++ };+ let texture_size = size(+ DevicePixels(texture.width() as i32),+ DevicePixels(texture.height() as i32),+@@ -2583,6 +2600,7 @@ mod backdrop_blur_tests {+ border_color: transparent_black(),+ corner_radii: Corners::default(),+ border_widths: Edges::default(),++ fade: Default::default(),+ });+ }++@@ -2748,3 +2766,144 @@ mod backdrop_blur_tests {+ );+ }+ }++++#[cfg(test)]++mod streaming_image_tests {++ use super::*;++ use gpui::{++ AtlasKey, AtlasTile, ImageId, PlatformAtlas, RenderImageParams, StreamingImage,++ StreamingImageFormat,++ };++ use image::RgbaImage;++ use std::borrow::Cow;++++ const VIEW: i32 = 96;++ const WIDTH: i32 = 40;++ const HEIGHT: i32 = 30;++++ fn new_renderer() -> Option<MetalRenderer> {++ metal::Device::system_default()?;++ Some(++ MetalRenderer::new_headless(Arc::new(Mutex::new(InstanceBufferPool::default())))++ .expect("failed to initialize headless renderer"),++ )++ }++++ fn bgra_pattern() -> Vec<u8> {++ let mut seed = 0x2545_f491_u32;++ let mut bytes = Vec::with_capacity((WIDTH * HEIGHT * 4) as usize);++ for _ in 0..WIDTH * HEIGHT {++ for _ in 0..3 {++ seed ^= seed << 13;++ seed ^= seed >> 17;++ seed ^= seed << 5;++ bytes.push(seed as u8);++ }++ bytes.push(255);++ }++ bytes++ }++++ fn frame_size() -> Size<DevicePixels> {++ size(DevicePixels(WIDTH), DevicePixels(HEIGHT))++ }++++ fn render(renderer: &mut MetalRenderer, tile: Option<AtlasTile>) -> RgbaImage {++ let viewport = Bounds {++ origin: point(ScaledPixels(0.), ScaledPixels(0.)),++ size: size(ScaledPixels(VIEW as f32), ScaledPixels(VIEW as f32)),++ };++ let mut scene = Scene::default();++ if let Some(tile) = tile {++ scene.insert_primitive(PolychromeSprite {++ order: 0,++ pad: 0,++ grayscale: false.into(),++ opacity: 1.,++ bounds: Bounds {++ origin: point(ScaledPixels(10.), ScaledPixels(12.)),++ size: size(ScaledPixels(WIDTH as f32), ScaledPixels(HEIGHT as f32)),++ },++ content_mask: ContentMask { bounds: viewport },++ corner_radii: Corners::default(),++ fade: Default::default(),++ tile,++ });++ }++ scene.finish();++ renderer++ .render_scene_to_image(&scene, size(DevicePixels(VIEW), DevicePixels(VIEW)))++ .expect("render_scene_to_image failed")++ }++++ #[test]++ fn stream_sprites_render_exactly_like_atlas_images() {++ let Some(mut renderer) = new_renderer() else {++ return;++ };++ let atlas = renderer.sprite_atlas().clone();++ let bgra = bgra_pattern();++ let image_tile = atlas++ .get_or_insert_with(++ &AtlasKey::Image(RenderImageParams {++ image_id: ImageId(usize::MAX),++ frame_index: 0,++ }),++ &mut || Ok(Some((frame_size(), Cow::Borrowed(bgra.as_slice())))),++ )++ .unwrap()++ .unwrap();++++ let bgra_stream = StreamingImage::new(StreamingImageFormat::Bgra8);++ bgra_stream++ .set_frame(frame_size(), WIDTH as usize * 4, bgra.clone())++ .unwrap();++ let bgra_tile = atlas++ .get_or_update_stream(bgra_stream.id(), &bgra_stream.current().unwrap())++ .unwrap()++ .unwrap();++++ let stride = WIDTH as usize * 4 + 64;++ let mut rgba = vec![0x5a; stride * HEIGHT as usize];++ for (row, source) in rgba++ .chunks_exact_mut(stride)++ .zip(bgra.chunks_exact(WIDTH as usize * 4))++ {++ for (pixel, source) in row.chunks_exact_mut(4).zip(source.chunks_exact(4)) {++ pixel.copy_from_slice(&[source[2], source[1], source[0], source[3]]);++ }++ }++ let rgba_stream = StreamingImage::new(StreamingImageFormat::Rgba8);++ rgba_stream.set_frame(frame_size(), stride, rgba).unwrap();++ let rgba_tile = atlas++ .get_or_update_stream(rgba_stream.id(), &rgba_stream.current().unwrap())++ .unwrap()++ .unwrap();++++ let expected = render(&mut renderer, Some(image_tile));++ let pixel = expected.get_pixel(10, 12);++ assert_eq!(pixel.0, [bgra[2], bgra[1], bgra[0], 255]);++ assert_ne!(expected, render(&mut renderer, None));++ assert!(render(&mut renderer, Some(bgra_tile)) == expected);++ assert!(render(&mut renderer, Some(rgba_tile)) == expected);++ }++++ #[test]++ fn removed_stream_batches_are_skipped() {++ let Some(mut renderer) = new_renderer() else {++ return;++ };++ let atlas = renderer.sprite_atlas().clone();++ let stream = StreamingImage::new(StreamingImageFormat::Bgra8);++ stream++ .set_frame(frame_size(), WIDTH as usize * 4, bgra_pattern())++ .unwrap();++ let tile = atlas++ .get_or_update_stream(stream.id(), &stream.current().unwrap())++ .unwrap()++ .unwrap();++ atlas.remove_stream(stream.id());++++ assert!(render(&mut renderer, Some(tile)) == render(&mut renderer, None));++ }++}+diff --git a/crates/gpui_wgpu/src/wgpu_atlas.rs b/crates/gpui_wgpu/src/wgpu_atlas.rs+index 3cf71ac..413add7 100644+--- a/crates/gpui_wgpu/src/wgpu_atlas.rs++++ b/crates/gpui_wgpu/src/wgpu_atlas.rs+@@ -3,7 +3,7 @@ use collections::FxHashMap;+ use etagere::{BucketedAtlasAllocator, size2};+ use gpui::{+ AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTextureList, AtlasTile, Bounds, DevicePixels,+- PlatformAtlas, Point, Size,++ PlatformAtlas, Point, Size, StreamFrame, StreamingImageFormat, StreamingImageId,+ };+ use parking_lot::Mutex;+ use std::{borrow::Cow, ops, sync::Arc};+@@ -23,6 +23,14 @@ fn etagere_point_to_device(point: etagere::Point) -> Point<DevicePixels> {++ pub struct WgpuAtlas(Mutex<WgpuAtlasState>);+++#[cfg(not(test))]++const STREAM_TEXTURE_USAGES: wgpu::TextureUsages =++ wgpu::TextureUsages::TEXTURE_BINDING.union(wgpu::TextureUsages::COPY_DST);++#[cfg(test)]++const STREAM_TEXTURE_USAGES: wgpu::TextureUsages = wgpu::TextureUsages::TEXTURE_BINDING++ .union(wgpu::TextureUsages::COPY_DST)++ .union(wgpu::TextureUsages::COPY_SRC);+++ struct PendingUpload {+ id: AtlasTextureId,+ bounds: Bounds<DevicePixels>,+@@ -37,6 +45,22 @@ struct WgpuAtlasState {+ storage: WgpuAtlasStorage,+ tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,+ pending_uploads: Vec<PendingUpload>,++ streams: Vec<WgpuAtlasStream>,++ next_stream_index: u32,++}++++/// A streaming image's texture. Frames are written straight into it while++/// painting; wgpu orders those writes after earlier submissions that sample it.++struct WgpuAtlasStream {++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ format: wgpu::TextureFormat,++ swizzle: bool,++ generation: u64,++ texture: wgpu::Texture,++ view: wgpu::TextureView,++ scratch: Vec<u8>,+ }++ pub struct WgpuTextureInfo {+@@ -58,6 +82,8 @@ impl WgpuAtlas {+ storage: WgpuAtlasStorage::default(),+ tiles_by_key: Default::default(),+ pending_uploads: Vec::new(),++ streams: Vec::new(),++ next_stream_index: 0,+ }))+ }++@@ -82,6 +108,19 @@ impl WgpuAtlas {+ }+ }+++ /// The view of a streaming image's texture, or `None` once the stream has++ /// been removed.++ pub fn get_stream_texture_info(&self, id: AtlasTextureId) -> Option<WgpuTextureInfo> {++ let lock = self.0.lock();++ let stream = lock++ .streams++ .iter()++ .find(|stream| stream.index == id.index)?;++ Some(WgpuTextureInfo {++ view: stream.view.clone(),++ })++ }+++ /// Clears all cached textures and tiles, forcing them to be recreated.+ /// Use this for incremental recovery when the device is still valid.+ pub fn clear(&self) {+@@ -89,6 +128,7 @@ impl WgpuAtlas {+ lock.storage = WgpuAtlasStorage::default();+ lock.tiles_by_key.clear();+ lock.pending_uploads.clear();++ lock.streams.clear();+ }++ /// Handles device lost by clearing all textures and cached tiles.+@@ -101,6 +141,7 @@ impl WgpuAtlas {+ lock.storage = WgpuAtlasStorage::default();+ lock.tiles_by_key.clear();+ lock.pending_uploads.clear();++ lock.streams.clear();+ }+ }++@@ -153,9 +194,106 @@ impl PlatformAtlas for WgpuAtlas {+ }+ }+ }++++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> Result<Option<AtlasTile>> {++ self.0.lock().update_stream(id, frame).map(Some)++ }++++ fn remove_stream(&self, id: StreamingImageId) {++ self.0.lock().streams.retain(|stream| stream.id != id);++ }+ }++ impl WgpuAtlasState {++ fn update_stream(&mut self, id: StreamingImageId, frame: &StreamFrame) -> Result<AtlasTile> {++ let size = frame.size();++ anyhow::ensure!(++ size.width.0 as u32 <= self.max_texture_size++ && size.height.0 as u32 <= self.max_texture_size,++ "streaming image frame {}x{} exceeds the {} pixel texture limit",++ size.width.0,++ size.height.0,++ self.max_texture_size++ );++ u32::try_from(frame.stride()).context("streaming image stride is too large")?;++ let (format, swizzle) = match frame.format() {++ StreamingImageFormat::Rgba8 => (wgpu::TextureFormat::Rgba8Unorm, false),++ StreamingImageFormat::Bgra8++ if self.color_texture_format == wgpu::TextureFormat::Bgra8Unorm =>++ {++ (wgpu::TextureFormat::Bgra8Unorm, false)++ }++ StreamingImageFormat::Bgra8 => (wgpu::TextureFormat::Rgba8Unorm, true),++ };++ let position = self.streams.iter().position(|stream| stream.id == id);++ let position = match position {++ Some(position)++ if self.streams[position].size == size++ && self.streams[position].format == format++ && self.streams[position].swizzle == swizzle =>++ {++ position++ }++ Some(position) => {++ let index = self.streams[position].index;++ self.streams[position] = self.new_stream(id, index, size, format, swizzle);++ position++ }++ None => {++ let index = self.next_stream_index;++ self.next_stream_index = self.next_stream_index.wrapping_add(1);++ let stream = self.new_stream(id, index, size, format, swizzle);++ self.streams.push(stream);++ self.streams.len() - 1++ }++ };++ let stream = &mut self.streams[position];++ if stream.generation != frame.generation() {++ stream.write(&self.queue, frame);++ }++ Ok(AtlasTile::for_stream(stream.index, size))++ }++++ fn new_stream(++ &self,++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ format: wgpu::TextureFormat,++ swizzle: bool,++ ) -> WgpuAtlasStream {++ let texture = self.device.create_texture(&wgpu::TextureDescriptor {++ label: Some("streaming_image"),++ size: wgpu::Extent3d {++ width: size.width.0 as u32,++ height: size.height.0 as u32,++ depth_or_array_layers: 1,++ },++ mip_level_count: 1,++ sample_count: 1,++ dimension: wgpu::TextureDimension::D2,++ format,++ usage: STREAM_TEXTURE_USAGES,++ view_formats: &[],++ });++ let view = texture.create_view(&wgpu::TextureViewDescriptor::default());++ WgpuAtlasStream {++ id,++ index,++ size,++ format,++ swizzle,++ generation: 0,++ texture,++ view,++ scratch: Vec::new(),++ }++ }+++ fn allocate(+ &mut self,+ size: Size<DevicePixels>,+@@ -196,6 +334,7 @@ impl WgpuAtlasState {+ let format = match kind {+ AtlasTextureKind::Monochrome => wgpu::TextureFormat::R8Unorm,+ AtlasTextureKind::Subpixel | AtlasTextureKind::Polychrome => self.color_texture_format,++ AtlasTextureKind::Stream => unreachable!(),+ };++ let texture = self.device.create_texture(&wgpu::TextureDescriptor {+@@ -306,6 +445,7 @@ impl ops::Index<AtlasTextureKind> for WgpuAtlasStorage {+ AtlasTextureKind::Monochrome => &self.monochrome_textures,+ AtlasTextureKind::Subpixel => &self.subpixel_textures,+ AtlasTextureKind::Polychrome => &self.polychrome_textures,++ AtlasTextureKind::Stream => unreachable!(),+ }+ }+ }+@@ -316,6 +456,7 @@ impl ops::IndexMut<AtlasTextureKind> for WgpuAtlasStorage {+ AtlasTextureKind::Monochrome => &mut self.monochrome_textures,+ AtlasTextureKind::Subpixel => &mut self.subpixel_textures,+ AtlasTextureKind::Polychrome => &mut self.polychrome_textures,++ AtlasTextureKind::Stream => unreachable!(),+ }+ }+ }+@@ -336,6 +477,7 @@ impl ops::Index<AtlasTextureId> for WgpuAtlasStorage {+ AtlasTextureKind::Monochrome => &self.monochrome_textures,+ AtlasTextureKind::Subpixel => &self.subpixel_textures,+ AtlasTextureKind::Polychrome => &self.polychrome_textures,++ AtlasTextureKind::Stream => unreachable!(),+ };+ textures[id.index as usize]+ .as_ref()+@@ -343,6 +485,47 @@ impl ops::Index<AtlasTextureId> for WgpuAtlasStorage {+ }+ }+++impl WgpuAtlasStream {++ fn write(&mut self, queue: &wgpu::Queue, frame: &StreamFrame) {++ let width = self.size.width.0 as u32;++ let height = self.size.height.0 as u32;++ let (data, bytes_per_row) = if self.swizzle {++ let row_bytes = width as usize * 4;++ self.scratch.clear();++ self.scratch.reserve(row_bytes * height as usize);++ for row in frame.bytes().chunks(frame.stride()).take(height as usize) {++ for pixel in row[..row_bytes].chunks_exact(4) {++ self.scratch++ .extend_from_slice(&[pixel[2], pixel[1], pixel[0], pixel[3]]);++ }++ }++ (self.scratch.as_slice(), row_bytes as u32)++ } else {++ (frame.bytes(), frame.stride() as u32)++ };++ queue.write_texture(++ wgpu::TexelCopyTextureInfo {++ texture: &self.texture,++ mip_level: 0,++ origin: wgpu::Origin3d::ZERO,++ aspect: wgpu::TextureAspect::All,++ },++ data,++ wgpu::TexelCopyBufferLayout {++ offset: 0,++ bytes_per_row: Some(bytes_per_row),++ rows_per_image: None,++ },++ wgpu::Extent3d {++ width,++ height,++ depth_or_array_layers: 1,++ },++ );++ self.generation = frame.generation();++ }++}+++ struct WgpuAtlasTexture {+ id: AtlasTextureId,+ allocator: BucketedAtlasAllocator,+@@ -402,13 +585,13 @@ fn swizzle_upload_data(bytes: &[u8], format: wgpu::TextureFormat) -> Vec<u8> {+ mod tests {+ use super::*;+ use gpui::block_on;+- use gpui::{ImageId, RenderImageParams};++ use gpui::{ImageId, RenderImageParams, StreamingImage};+ use std::sync::Arc;++ fn test_device_and_queue() -> anyhow::Result<(Arc<wgpu::Device>, Arc<wgpu::Queue>)> {+ block_on(async {+ let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {+- backends: wgpu::Backends::all(),++ backends: wgpu::Backends::from_env().unwrap_or(wgpu::Backends::all()),+ flags: wgpu::InstanceFlags::default(),+ backend_options: wgpu::BackendOptions::default(),+ memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),+@@ -422,6 +605,11 @@ mod tests {+ })+ .await+ .map_err(|error| anyhow::anyhow!("failed to request adapter: {error}"))?;++ let info = adapter.get_info();++ eprintln!(++ "wgpu test adapter: {} ({:?}, {:?})",++ info.name, info.backend, info.device_type++ );+ let (device, queue) = adapter+ .request_device(&wgpu::DeviceDescriptor {+ label: Some("wgpu_atlas_test_device"),+@@ -507,6 +695,396 @@ mod tests {+ Ok(())+ }+++ struct StreamTest {++ device: Arc<wgpu::Device>,++ queue: Arc<wgpu::Queue>,++ atlas: WgpuAtlas,++ }++++ fn stream_test(color_texture_format: wgpu::TextureFormat) -> Option<StreamTest> {++ let (device, queue) = match test_device_and_queue() {++ Ok(device_and_queue) => device_and_queue,++ Err(error) => {++ eprintln!("skipping: {error}");++ return None;++ }++ };++ let atlas = WgpuAtlas::new(device.clone(), queue.clone(), color_texture_format);++ Some(StreamTest {++ device,++ queue,++ atlas,++ })++ }++++ fn stream_size(width: i32, height: i32) -> Size<DevicePixels> {++ Size {++ width: DevicePixels(width),++ height: DevicePixels(height),++ }++ }++++ fn pixels(size: Size<DevicePixels>, seed: u8) -> Vec<u8> {++ (0..size.width.0 * size.height.0 * 4)++ .map(|index| (index as u8).wrapping_mul(31).wrapping_add(seed))++ .collect()++ }++++ fn set_frame(image: &StreamingImage, size: Size<DevicePixels>, bytes: Vec<u8>) -> StreamFrame {++ image++ .set_frame(size, size.width.0 as usize * 4, bytes)++ .unwrap();++ image.current().unwrap()++ }++++ fn update(atlas: &WgpuAtlas, image: &StreamingImage, frame: &StreamFrame) -> AtlasTile {++ atlas++ .get_or_update_stream(image.id(), frame)++ .expect("stream upload should succeed")++ .expect("stream upload returns a tile")++ }++++ fn stream_texture(atlas: &WgpuAtlas, image: &StreamingImage) -> wgpu::Texture {++ atlas++ .0++ .lock()++ .streams++ .iter()++ .find(|stream| stream.id == image.id())++ .expect("stream should exist")++ .texture++ .clone()++ }++++ fn copy_to_buffer(++ test: &StreamTest,++ texture: &wgpu::Texture,++ bounds: Bounds<DevicePixels>,++ ) -> wgpu::Buffer {++ let bytes_per_row =++ (bounds.size.width.0 as u32 * 4).next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT);++ let buffer = test.device.create_buffer(&wgpu::BufferDescriptor {++ label: Some("stream_readback"),++ size: (bytes_per_row * bounds.size.height.0 as u32) as u64,++ usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,++ mapped_at_creation: false,++ });++ let mut encoder = test++ .device++ .create_command_encoder(&wgpu::CommandEncoderDescriptor::default());++ encoder.copy_texture_to_buffer(++ wgpu::TexelCopyTextureInfo {++ texture,++ mip_level: 0,++ origin: wgpu::Origin3d {++ x: bounds.origin.x.0 as u32,++ y: bounds.origin.y.0 as u32,++ z: 0,++ },++ aspect: wgpu::TextureAspect::All,++ },++ wgpu::TexelCopyBufferInfo {++ buffer: &buffer,++ layout: wgpu::TexelCopyBufferLayout {++ offset: 0,++ bytes_per_row: Some(bytes_per_row),++ rows_per_image: None,++ },++ },++ wgpu::Extent3d {++ width: bounds.size.width.0 as u32,++ height: bounds.size.height.0 as u32,++ depth_or_array_layers: 1,++ },++ );++ test.queue.submit(Some(encoder.finish()));++ buffer++ }++++ fn read_buffer(test: &StreamTest, buffer: &wgpu::Buffer, size: Size<DevicePixels>) -> Vec<u8> {++ buffer.map_async(wgpu::MapMode::Read, .., |result| result.unwrap());++ test.device++ .poll(wgpu::PollType::wait_indefinitely())++ .unwrap();++ let row_bytes = size.width.0 as usize * 4;++ let bytes_per_row = buffer.size() as usize / size.height.0 as usize;++ let mapped = buffer.get_mapped_range(..);++ let bytes = mapped++ .chunks(bytes_per_row)++ .flat_map(|row| row[..row_bytes].to_vec())++ .collect();++ drop(mapped);++ buffer.unmap();++ bytes++ }++++ fn read_stream(test: &StreamTest, image: &StreamingImage, size: Size<DevicePixels>) -> Vec<u8> {++ let texture = stream_texture(&test.atlas, image);++ let bounds = Bounds {++ origin: Point::default(),++ size,++ };++ let buffer = copy_to_buffer(test, &texture, bounds);++ read_buffer(test, &buffer, size)++ }++++ fn swizzled(bytes: &[u8]) -> Vec<u8> {++ bytes++ .chunks_exact(4)++ .flat_map(|pixel| [pixel[2], pixel[1], pixel[0], pixel[3]])++ .collect()++ }++++ #[test]++ fn stream_updates_of_the_same_size_reuse_one_texture() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 36);++ let first = update(++ &test.atlas,++ &image,++ &set_frame(&image, size, pixels(size, 1)),++ );++ let texture = stream_texture(&test.atlas, &image);++ for seed in 2..10 {++ let tile = update(++ &test.atlas,++ &image,++ &set_frame(&image, size, pixels(size, seed)),++ );++ assert_eq!(tile, first);++ }++++ assert_eq!(first.texture_id.kind, AtlasTextureKind::Stream);++ assert_eq!(first.bounds.size, size);++ assert!(stream_texture(&test.atlas, &image) == texture);++ assert_eq!(read_stream(&test, &image, size), pixels(size, 9));++ }++++ #[test]++ fn stream_size_change_reallocates_once() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let small = stream_size(64, 36);++ let large = stream_size(128, 72);++ let small_tile = update(++ &test.atlas,++ &image,++ &set_frame(&image, small, pixels(small, 1)),++ );++ let small_texture = stream_texture(&test.atlas, &image);++ let large_tile = update(++ &test.atlas,++ &image,++ &set_frame(&image, large, pixels(large, 2)),++ );++ let large_texture = stream_texture(&test.atlas, &image);++ update(++ &test.atlas,++ &image,++ &set_frame(&image, large, pixels(large, 3)),++ );++++ assert_eq!(large_tile.texture_id, small_tile.texture_id);++ assert_eq!(large_tile.bounds.size, large);++ assert!(large_texture != small_texture);++ assert!(stream_texture(&test.atlas, &image) == large_texture);++ assert_eq!(read_stream(&test, &image, large), pixels(large, 3));++ }++++ #[test]++ fn images_and_streams_never_share_textures() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let size = stream_size(64, 64);++ let image_key = AtlasKey::Image(RenderImageParams {++ image_id: ImageId(1),++ frame_index: 0,++ });++ let image_tile = test++ .atlas++ .get_or_insert_with(&image_key, &mut || {++ Ok(Some((size, Cow::Owned(pixels(size, 1)))))++ })++ .unwrap()++ .unwrap();++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let stream_tile = update(++ &test.atlas,++ &image,++ &set_frame(&image, size, pixels(size, 2)),++ );++++ assert_eq!(image_tile.texture_id.kind, AtlasTextureKind::Polychrome);++ assert_eq!(stream_tile.texture_id.kind, AtlasTextureKind::Stream);++ assert_eq!(++ test.atlas++ .0++ .lock()++ .storage++ .polychrome_textures++ .iter_mut()++ .count(),++ 1++ );++++ test.atlas.remove(&image_key);++ test.atlas.before_frame();++ assert!(++ test.atlas++ .get_stream_texture_info(stream_tile.texture_id)++ .is_some()++ );++ test.atlas.remove_stream(image.id());++ assert!(++ test.atlas++ .get_stream_texture_info(stream_tile.texture_id)++ .is_none()++ );++ test.atlas.remove_stream(image.id());++ }++++ #[test]++ fn stream_textures_hold_what_atlas_image_tiles_hold() {++ for atlas_format in [++ wgpu::TextureFormat::Bgra8Unorm,++ wgpu::TextureFormat::Rgba8Unorm,++ ] {++ let Some(test) = stream_test(atlas_format) else {++ return;++ };++ let size = stream_size(64, 32);++ let bgra = pixels(size, 7);++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ update(&test.atlas, &image, &set_frame(&image, size, bgra.clone()));++++ assert_eq!(stream_texture(&test.atlas, &image).format(), atlas_format);++ assert_eq!(++ read_stream(&test, &image, size),++ swizzle_upload_data(&bgra, atlas_format)++ );++ }++ }++++ #[test]++ fn stream_formats_and_strides_upload_the_same_pixels() {++ for atlas_format in [++ wgpu::TextureFormat::Bgra8Unorm,++ wgpu::TextureFormat::Rgba8Unorm,++ ] {++ let Some(test) = stream_test(atlas_format) else {++ return;++ };++ let size = stream_size(64, 16);++ let bgra = pixels(size, 3);++ let rgba = swizzled(&bgra);++++ let bgra_image = StreamingImage::new(StreamingImageFormat::Bgra8);++ update(++ &test.atlas,++ &bgra_image,++ &set_frame(&bgra_image, size, bgra.clone()),++ );++ let stride = 64 * 4 + 32;++ let mut padded = vec![0xee; stride * 16];++ for (row, source) in padded++ .chunks_exact_mut(stride)++ .zip(rgba.chunks_exact(64 * 4))++ {++ row[..64 * 4].copy_from_slice(source);++ }++ let rgba_image = StreamingImage::new(StreamingImageFormat::Rgba8);++ rgba_image.set_frame(size, stride, padded).unwrap();++ update(&test.atlas, &rgba_image, &rgba_image.current().unwrap());++++ let bgra_texture = stream_texture(&test.atlas, &bgra_image);++ let rgba_texture = stream_texture(&test.atlas, &rgba_image);++ assert_eq!(rgba_texture.format(), wgpu::TextureFormat::Rgba8Unorm);++ let as_rgba = |texture: &wgpu::Texture, bytes: Vec<u8>| match texture.format() {++ wgpu::TextureFormat::Bgra8Unorm => swizzled(&bytes),++ _ => bytes,++ };++ assert_eq!(++ as_rgba(&bgra_texture, read_stream(&test, &bgra_image, size)),++ rgba++ );++ assert_eq!(read_stream(&test, &rgba_image, size), rgba);++ }++ }++++ #[test]++ fn stream_writes_are_ordered_with_submitted_reads() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 64);++ let bounds = Bounds {++ origin: Point::default(),++ size,++ };++ update(++ &test.atlas,++ &image,++ &set_frame(&image, size, pixels(size, 1)),++ );++ let texture = stream_texture(&test.atlas, &image);++ let first = copy_to_buffer(&test, &texture, bounds);++ update(++ &test.atlas,++ &image,++ &set_frame(&image, size, pixels(size, 2)),++ );++ let second = copy_to_buffer(&test, &texture, bounds);++++ assert_eq!(read_buffer(&test, &first, size), pixels(size, 1));++ assert_eq!(read_buffer(&test, &second, size), pixels(size, 2));++ }++++ #[test]++ fn cleared_atlas_uploads_streams_again() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 8);++ let frame = set_frame(&image, size, pixels(size, 4));++ let tile = update(&test.atlas, &image, &frame);++ let texture = stream_texture(&test.atlas, &image);++++ test.atlas.clear();++ assert!(++ test.atlas++ .get_stream_texture_info(tile.texture_id)++ .is_none()++ );++ let tile = update(&test.atlas, &image, &frame);++ assert!(++ test.atlas++ .get_stream_texture_info(tile.texture_id)++ .is_some()++ );++ assert!(stream_texture(&test.atlas, &image) != texture);++ assert_eq!(read_stream(&test, &image, size), pixels(size, 4));++ }++++ #[test]++ fn oversized_stream_frames_are_rejected() {++ let Some(test) = stream_test(wgpu::TextureFormat::Bgra8Unorm) else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let width = test.atlas.0.lock().max_texture_size as i32 + 1;++ let size = stream_size(width, 1);++ let frame = set_frame(&image, size, vec![0; width as usize * 4]);++ assert!(test.atlas.get_or_update_stream(image.id(), &frame).is_err());++ }+++ #[test]+ fn swizzle_upload_data_preserves_bgra_uploads() {+ let input = vec![0x10, 0x20, 0x30, 0x40];+diff --git a/crates/gpui_wgpu/src/wgpu_renderer.rs b/crates/gpui_wgpu/src/wgpu_renderer.rs+index 729a5c4..2bfbc4e 100644+--- a/crates/gpui_wgpu/src/wgpu_renderer.rs++++ b/crates/gpui_wgpu/src/wgpu_renderer.rs+@@ -2,9 +2,9 @@ use crate::surface_frame::SurfaceFrame;+ use crate::{CompositorGpuHint, WgpuAtlas, WgpuContext};+ use bytemuck::{Pod, Zeroable};+ use gpui::{+- AtlasTextureId, Background, Bounds, DevicePixels, GpuSpecs, MonochromeSprite, Path, Point,+- PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, SubpixelSprite,+- Underline, get_gamma_correction_ratios,++ AtlasTextureId, AtlasTextureKind, Background, Bounds, DevicePixels, GpuSpecs, MonochromeSprite,++ Path, Point, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,++ SubpixelSprite, Underline, get_gamma_correction_ratios,+ };+ use log::warn;+ #[cfg(not(target_family = "wasm"))]+@@ -1448,7 +1448,14 @@ impl WgpuRenderer {+ instance_offset: &mut u64,+ pass: &mut wgpu::RenderPass<'_>,+ ) -> bool {+- let tex_info = self.atlas.get_texture_info(texture_id);++ let tex_info = if texture_id.kind == AtlasTextureKind::Stream {++ let Some(tex_info) = self.atlas.get_stream_texture_info(texture_id) else {++ return true;++ };++ tex_info++ } else {++ self.atlas.get_texture_info(texture_id)++ };+ let data = unsafe { Self::instance_bytes(sprites) };+ self.draw_instances_with_texture(+ data,+diff --git a/crates/gpui_windows/src/directx_atlas.rs b/crates/gpui_windows/src/directx_atlas.rs+index d49ec18..cea181d 100644+--- a/crates/gpui_windows/src/directx_atlas.rs++++ b/crates/gpui_windows/src/directx_atlas.rs+@@ -11,9 +11,11 @@ use windows::Win32::Graphics::{++ use gpui::{+ AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTextureList, AtlasTile, Bounds, DevicePixels,+- PlatformAtlas, Point, Size,++ PlatformAtlas, Point, Size, StreamFrame, StreamingImageFormat, StreamingImageId,+ };+++const MAX_STREAM_TEXTURE_SIZE: i32 = 16384;+++ pub(crate) struct DirectXAtlas(Mutex<DirectXAtlasState>);++ struct DirectXAtlasState {+@@ -23,6 +25,20 @@ struct DirectXAtlasState {+ polychrome_textures: AtlasTextureList<DirectXAtlasTexture>,+ subpixel_textures: AtlasTextureList<DirectXAtlasTexture>,+ tiles_by_key: FxHashMap<AtlasKey, AtlasTile>,++ streams: Vec<DirectXAtlasStream>,++ next_stream_index: u32,++}++++/// A streaming image's texture, written with `UpdateSubresource`; the++/// immediate context orders each write after earlier draws that sample it.++struct DirectXAtlasStream {++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ format: DXGI_FORMAT,++ generation: u64,++ texture: ID3D11Texture2D,++ view: [Option<ID3D11ShaderResourceView>; 1],+ }++ struct DirectXAtlasTexture {+@@ -43,9 +59,23 @@ impl DirectXAtlas {+ polychrome_textures: Default::default(),+ subpixel_textures: Default::default(),+ tiles_by_key: Default::default(),++ streams: Vec::new(),++ next_stream_index: 0,+ }))+ }+++ pub(crate) fn get_stream_texture_view(++ &self,++ id: AtlasTextureId,++ ) -> Option<[Option<ID3D11ShaderResourceView>; 1]> {++ let lock = self.0.lock();++ let stream = lock++ .streams++ .iter()++ .find(|stream| stream.index == id.index)?;++ Some(stream.view.clone())++ }+++ pub(crate) fn get_texture_view(+ &self,+ id: AtlasTextureId,+@@ -67,6 +97,7 @@ impl DirectXAtlas {+ lock.polychrome_textures = AtlasTextureList::default();+ lock.subpixel_textures = AtlasTextureList::default();+ lock.tiles_by_key.clear();++ lock.streams.clear();+ }+ }++@@ -107,6 +138,7 @@ impl PlatformAtlas for DirectXAtlas {+ AtlasTextureKind::Monochrome => &mut lock.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut lock.polychrome_textures,+ AtlasTextureKind::Subpixel => &mut lock.subpixel_textures,++ AtlasTextureKind::Stream => unreachable!(),+ };+ let cached_texture_index = if id.kind == AtlasTextureKind::Polychrome {+ textures.textures.iter().position(|entry| {+@@ -138,6 +170,18 @@ impl PlatformAtlas for DirectXAtlas {+ }+ }+ }++++ fn get_or_update_stream(++ &self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> anyhow::Result<Option<AtlasTile>> {++ self.0.lock().update_stream(id, frame)++ }++++ fn remove_stream(&self, id: StreamingImageId) {++ self.0.lock().streams.retain(|stream| stream.id != id);++ }+ }++ impl DirectXAtlasState {+@@ -151,6 +195,7 @@ impl DirectXAtlasState {+ AtlasTextureKind::Monochrome => &mut self.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut self.polychrome_textures,+ AtlasTextureKind::Subpixel => &mut self.subpixel_textures,++ AtlasTextureKind::Stream => unreachable!(),+ };++ if let Some(tile) = textures+@@ -201,6 +246,7 @@ impl DirectXAtlasState {+ bind_flag = D3D11_BIND_SHADER_RESOURCE;+ bytes_per_pixel = 4;+ }++ AtlasTextureKind::Stream => unreachable!(),+ }+ let texture_desc = D3D11_TEXTURE2D_DESC {+ Width: size.width.0 as u32,+@@ -231,6 +277,7 @@ impl DirectXAtlasState {+ AtlasTextureKind::Monochrome => &mut self.monochrome_textures,+ AtlasTextureKind::Polychrome => &mut self.polychrome_textures,+ AtlasTextureKind::Subpixel => &mut self.subpixel_textures,++ AtlasTextureKind::Stream => unreachable!(),+ };+ let index = texture_list.free_list.pop();+ let view = unsafe {+@@ -271,7 +318,113 @@ impl DirectXAtlasState {+ AtlasTextureKind::Subpixel => {+ &self.subpixel_textures[id.index as usize].as_ref().unwrap()+ }++ AtlasTextureKind::Stream => unreachable!(),++ }++ }++++ fn update_stream(++ &mut self,++ id: StreamingImageId,++ frame: &StreamFrame,++ ) -> anyhow::Result<Option<AtlasTile>> {++ let size = frame.size();++ anyhow::ensure!(++ size.width.0 <= MAX_STREAM_TEXTURE_SIZE && size.height.0 <= MAX_STREAM_TEXTURE_SIZE,++ "streaming image frame {}x{} exceeds the {MAX_STREAM_TEXTURE_SIZE} pixel texture limit",++ size.width.0,++ size.height.0++ );++ let stride = u32::try_from(frame.stride())++ .map_err(|_| anyhow::anyhow!("streaming image stride is too large"))?;++ let format = match frame.format() {++ StreamingImageFormat::Bgra8 => DXGI_FORMAT_B8G8R8A8_UNORM,++ StreamingImageFormat::Rgba8 => DXGI_FORMAT_R8G8B8A8_UNORM,++ };++ let position = self.streams.iter().position(|stream| stream.id == id);++ let position = match position {++ Some(position)++ if self.streams[position].size == size++ && self.streams[position].format == format =>++ {++ position++ }++ Some(position) => {++ let index = self.streams[position].index;++ let Some(stream) = self.new_stream(id, index, size, format) else {++ self.streams.remove(position);++ return Ok(None);++ };++ self.streams[position] = stream;++ position++ }++ None => {++ let index = self.next_stream_index;++ let Some(stream) = self.new_stream(id, index, size, format) else {++ return Ok(None);++ };++ self.next_stream_index = self.next_stream_index.wrapping_add(1);++ self.streams.push(stream);++ self.streams.len() - 1++ }++ };++ let stream = &mut self.streams[position];++ if stream.generation != frame.generation() {++ unsafe {++ self.device_context.UpdateSubresource(++ &stream.texture,++ 0,++ None,++ frame.bytes().as_ptr() as _,++ stride,++ 0,++ );++ }++ stream.generation = frame.generation();+ }++ Ok(Some(AtlasTile::for_stream(stream.index, size)))++ }++++ fn new_stream(++ &self,++ id: StreamingImageId,++ index: u32,++ size: Size<DevicePixels>,++ format: DXGI_FORMAT,++ ) -> Option<DirectXAtlasStream> {++ let texture_desc = D3D11_TEXTURE2D_DESC {++ Width: size.width.0 as u32,++ Height: size.height.0 as u32,++ MipLevels: 1,++ ArraySize: 1,++ Format: format,++ SampleDesc: DXGI_SAMPLE_DESC {++ Count: 1,++ Quality: 0,++ },++ Usage: D3D11_USAGE_DEFAULT,++ BindFlags: D3D11_BIND_SHADER_RESOURCE.0 as u32,++ CPUAccessFlags: 0,++ MiscFlags: 0,++ };++ let mut texture: Option<ID3D11Texture2D> = None;++ let mut view = None;++ unsafe {++ self.device++ .CreateTexture2D(&texture_desc, None, Some(&mut texture))++ .ok()?;++ self.device++ .CreateShaderResourceView(texture.as_ref()?, None, Some(&mut view))++ .ok()?;++ }++ Some(DirectXAtlasStream {++ id,++ index,++ size,++ format,++ generation: 0,++ texture: texture?,++ view: [view],++ })+ }+ }++@@ -357,17 +510,26 @@ fn etagere_point_to_device(value: etagere::Point) -> Point<DevicePixels> {+ #[cfg(test)]+ mod tests {+ use super::*;+- use gpui::{ImageId, RenderImageParams};++ use gpui::{ImageId, RenderImageParams, StreamingImage};+ use std::borrow::Cow;+ use windows::Win32::{+ Foundation::HMODULE,+ Graphics::{+ Direct3D::D3D_DRIVER_TYPE_WARP,+- Direct3D11::{D3D11_CREATE_DEVICE_BGRA_SUPPORT, D3D11_SDK_VERSION, D3D11CreateDevice},++ Direct3D11::{++ D3D11_CPU_ACCESS_READ, D3D11_CREATE_DEVICE_BGRA_SUPPORT, D3D11_MAP_READ,++ D3D11_MAPPED_SUBRESOURCE, D3D11_SDK_VERSION, D3D11_USAGE_STAGING,++ D3D11CreateDevice,++ },+ },+ };++ fn create_atlas() -> Option<DirectXAtlas> {++ let (device, device_context) = create_device()?;++ Some(DirectXAtlas::new(&device, &device_context))++ }++++ fn create_device() -> Option<(ID3D11Device, ID3D11DeviceContext)> {+ let mut device: Option<ID3D11Device> = None;+ let mut device_context: Option<ID3D11DeviceContext> = None;+ unsafe {+@@ -384,7 +546,7 @@ mod tests {+ )+ }+ .ok()?;+- Some(DirectXAtlas::new(&device?, &device_context?))++ Some((device?, device_context?))+ }++ fn make_image_key(image_id: usize) -> AtlasKey {+@@ -433,6 +595,264 @@ mod tests {+ assert_eq!(tile_b.texture_id, keeper_tile.texture_id);+ }+++ fn stream_size(width: i32, height: i32) -> Size<DevicePixels> {++ Size {++ width: DevicePixels(width),++ height: DevicePixels(height),++ }++ }++++ fn pixels(size: Size<DevicePixels>, seed: u8) -> Vec<u8> {++ (0..size.width.0 * size.height.0 * 4)++ .map(|index| (index as u8).wrapping_mul(31).wrapping_add(seed))++ .collect()++ }++++ fn set_frame(image: &StreamingImage, size: Size<DevicePixels>, bytes: Vec<u8>) -> StreamFrame {++ image++ .set_frame(size, size.width.0 as usize * 4, bytes)++ .unwrap();++ image.current().unwrap()++ }++++ fn update(atlas: &DirectXAtlas, image: &StreamingImage, frame: &StreamFrame) -> AtlasTile {++ atlas++ .get_or_update_stream(image.id(), frame)++ .expect("stream upload should succeed")++ .expect("stream upload returns a tile")++ }++++ fn stream_texture(atlas: &DirectXAtlas, image: &StreamingImage) -> ID3D11Texture2D {++ atlas++ .0++ .lock()++ .streams++ .iter()++ .find(|stream| stream.id == image.id())++ .expect("stream should exist")++ .texture++ .clone()++ }++++ fn copy_to_staging(atlas: &DirectXAtlas, texture: &ID3D11Texture2D) -> ID3D11Texture2D {++ let lock = atlas.0.lock();++ let mut desc = D3D11_TEXTURE2D_DESC::default();++ unsafe { texture.GetDesc(&mut desc) };++ desc.Usage = D3D11_USAGE_STAGING;++ desc.BindFlags = 0;++ desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ.0 as u32;++ let mut staging: Option<ID3D11Texture2D> = None;++ unsafe {++ lock.device++ .CreateTexture2D(&desc, None, Some(&mut staging))++ .unwrap();++ let staging = staging.unwrap();++ lock.device_context.CopyResource(&staging, texture);++ staging++ }++ }++++ fn read_staging(atlas: &DirectXAtlas, staging: &ID3D11Texture2D) -> Vec<u8> {++ let lock = atlas.0.lock();++ let mut desc = D3D11_TEXTURE2D_DESC::default();++ unsafe { staging.GetDesc(&mut desc) };++ let mut mapped = D3D11_MAPPED_SUBRESOURCE::default();++ unsafe {++ lock.device_context++ .Map(staging, 0, D3D11_MAP_READ, 0, Some(&mut mapped))++ .unwrap();++ }++ let row_bytes = desc.Width as usize * 4;++ let mut bytes = Vec::with_capacity(row_bytes * desc.Height as usize);++ for row in 0..desc.Height as usize {++ let row = unsafe {++ std::slice::from_raw_parts(++ (mapped.pData as *const u8).add(row * mapped.RowPitch as usize),++ row_bytes,++ )++ };++ bytes.extend_from_slice(row);++ }++ unsafe { lock.device_context.Unmap(staging, 0) };++ bytes++ }++++ fn read_stream(atlas: &DirectXAtlas, image: &StreamingImage) -> Vec<u8> {++ let staging = copy_to_staging(atlas, &stream_texture(atlas, image));++ read_staging(atlas, &staging)++ }++++ fn swizzled(bytes: &[u8]) -> Vec<u8> {++ bytes++ .chunks_exact(4)++ .flat_map(|pixel| [pixel[2], pixel[1], pixel[0], pixel[3]])++ .collect()++ }++++ #[test]++ fn stream_updates_of_the_same_size_reuse_one_texture() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 36);++ let first = update(&atlas, &image, &set_frame(&image, size, pixels(size, 1)));++ let texture = stream_texture(&atlas, &image);++ for seed in 2..10 {++ let tile = update(&atlas, &image, &set_frame(&image, size, pixels(size, seed)));++ assert_eq!(tile, first);++ }++++ assert_eq!(first.texture_id.kind, AtlasTextureKind::Stream);++ assert_eq!(first.bounds.size, size);++ assert_eq!(stream_texture(&atlas, &image), texture);++ assert_eq!(read_stream(&atlas, &image), pixels(size, 9));++ }++++ #[test]++ fn stream_size_change_reallocates_once() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let small = stream_size(64, 36);++ let large = stream_size(128, 72);++ let small_tile = update(&atlas, &image, &set_frame(&image, small, pixels(small, 1)));++ let small_texture = stream_texture(&atlas, &image);++ let large_tile = update(&atlas, &image, &set_frame(&image, large, pixels(large, 2)));++ let large_texture = stream_texture(&atlas, &image);++ update(&atlas, &image, &set_frame(&image, large, pixels(large, 3)));++++ assert_eq!(large_tile.texture_id, small_tile.texture_id);++ assert_eq!(large_tile.bounds.size, large);++ assert_ne!(large_texture, small_texture);++ assert_eq!(stream_texture(&atlas, &image), large_texture);++ assert_eq!(read_stream(&atlas, &image), pixels(large, 3));++ }++++ #[test]++ fn removing_images_leaves_streams_alone() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let size = stream_size(64, 64);++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let stream_tile = update(&atlas, &image, &set_frame(&image, size, pixels(size, 5)));++ let stream = stream_texture(&atlas, &image);++++ let first_key = make_image_key(20);++ let second_key = make_image_key(21);++ let first = insert_tile(&atlas, &first_key, stream_size(1280, 720));++ atlas.remove(&first_key);++ let second = insert_tile(&atlas, &second_key, stream_size(1280, 720));++ atlas.remove(&second_key);++++ assert_eq!(first.texture_id.kind, AtlasTextureKind::Polychrome);++ assert_eq!(first.texture_id, second.texture_id);++ assert_eq!(++ atlas++ .0++ .lock()++ .polychrome_textures++ .textures++ .iter()++ .flatten()++ .count(),++ 1++ );++ assert!(++ atlas++ .get_stream_texture_view(stream_tile.texture_id)++ .is_some()++ );++ assert_eq!(stream_texture(&atlas, &image), stream);++ assert_eq!(read_stream(&atlas, &image), pixels(size, 5));++++ atlas.remove_stream(image.id());++ assert!(++ atlas++ .get_stream_texture_view(stream_tile.texture_id)++ .is_none()++ );++ atlas.remove_stream(image.id());++ }++++ #[test]++ fn device_loss_uploads_streams_again() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 8);++ let frame = set_frame(&image, size, pixels(size, 4));++ let tile = update(&atlas, &image, &frame);++++ let (device, device_context) = create_device().unwrap();++ atlas.handle_device_lost(&device, &device_context);++ assert!(atlas.get_stream_texture_view(tile.texture_id).is_none());++ let tile = update(&atlas, &image, &frame);++ assert!(atlas.get_stream_texture_view(tile.texture_id).is_some());++ assert_eq!(read_stream(&atlas, &image), pixels(size, 4));++ }++++ #[test]++ fn stream_writes_are_ordered_with_earlier_copies() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(64, 64);++ update(&atlas, &image, &set_frame(&image, size, pixels(size, 1)));++ let texture = stream_texture(&atlas, &image);++ let first = copy_to_staging(&atlas, &texture);++ update(&atlas, &image, &set_frame(&image, size, pixels(size, 2)));++ let second = copy_to_staging(&atlas, &texture);++++ assert_eq!(read_staging(&atlas, &first), pixels(size, 1));++ assert_eq!(read_staging(&atlas, &second), pixels(size, 2));++ }++++ #[test]++ fn stream_formats_and_strides_upload_the_same_pixels() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let size = stream_size(64, 16);++ let bgra = pixels(size, 3);++ let rgba = swizzled(&bgra);++ let bgra_image = StreamingImage::new(StreamingImageFormat::Bgra8);++ update(++ &atlas,++ &bgra_image,++ &set_frame(&bgra_image, size, bgra.clone()),++ );++ let stride = 64 * 4 + 32;++ let mut padded = vec![0xee; stride * 16];++ for (row, source) in padded++ .chunks_exact_mut(stride)++ .zip(rgba.chunks_exact(64 * 4))++ {++ row[..64 * 4].copy_from_slice(source);++ }++ let rgba_image = StreamingImage::new(StreamingImageFormat::Rgba8);++ rgba_image.set_frame(size, stride, padded).unwrap();++ update(&atlas, &rgba_image, &rgba_image.current().unwrap());++++ assert_eq!(read_stream(&atlas, &bgra_image), bgra);++ assert_eq!(read_stream(&atlas, &rgba_image), rgba);++ }++++ #[test]++ fn oversized_stream_frames_are_rejected() {++ let Some(atlas) = create_atlas() else {++ return;++ };++ let image = StreamingImage::new(StreamingImageFormat::Bgra8);++ let size = stream_size(MAX_STREAM_TEXTURE_SIZE + 1, 1);++ let frame = set_frame(&image, size, vec![0; size.width.0 as usize * 4]);++ assert!(atlas.get_or_update_stream(image.id(), &frame).is_err());++ }+++ #[test]+ fn test_reuses_one_unreferenced_polychrome_texture() {+ let Some(atlas) = create_atlas() else {+diff --git a/crates/gpui_windows/src/directx_renderer.rs b/crates/gpui_windows/src/directx_renderer.rs+index 35b504e..e4b605b 100644+--- a/crates/gpui_windows/src/directx_renderer.rs++++ b/crates/gpui_windows/src/directx_renderer.rs+@@ -712,7 +712,14 @@ impl DirectXRenderer {+ }+ let devices = self.devices.as_ref().context("devices missing")?;+ let resources = self.resources.as_ref().context("resources missing")?;+- let texture_view = self.atlas.get_texture_view(texture_id);++ let texture_view = if texture_id.kind == AtlasTextureKind::Stream {++ let Some(texture_view) = self.atlas.get_stream_texture_view(texture_id) else {++ return Ok(());++ };++ texture_view++ } else {++ self.atlas.get_texture_view(texture_id)++ };+ self.pipelines.poly_sprites.draw_range_with_texture(+ &devices.device,+ &devices.device_context,diff --git a/scripts/prepare-gpui-dependency.sh b/scripts/prepare-gpui-dependency.shindex bffbd90c1..18f1b8eb9 100755--- a/scripts/prepare-gpui-dependency.sh+++ b/scripts/prepare-gpui-dependency.sh@@ -8,6 +8,7 @@ patch_paths=("apps/desktop-gpui/patches/zed-windows.patch""apps/desktop-gpui/patches/zed-linux.patch""apps/desktop-gpui/patches/zed-idle-frames.patch"+ "apps/desktop-gpui/patches/zed-streaming-image.patch")patch_files=("${patch_paths[@]/#/$repo_root/}")base_revision="5d1f83d9f27a19bec1fb241dc33b42238af9cf8d"diff --git a/scripts/prepare-gpui-dependency.test.mjs b/scripts/prepare-gpui-dependency.test.mjsindex e66507100..98a920eb1 100644--- a/scripts/prepare-gpui-dependency.test.mjs+++ b/scripts/prepare-gpui-dependency.test.mjs@@ -122,6 +122,7 @@ test("dependency verification handles overlapping patches without changing the cwriteFileSync(path.join(upstream, "renderer.rs"), "base\n");writeFileSync(path.join(upstream, "windows.rs"), "base\n");writeFileSync(path.join(upstream, "frames.rs"), "base\n");+ writeFileSync(path.join(upstream, "atlas.rs"), "base\n");commit();const base = git(upstream, "rev-parse", "HEAD").trim();const patch = (name) => {@@ -142,6 +143,8 @@ test("dependency verification handles overlapping patches without changing the cpatch("zed-linux.patch");writeFileSync(path.join(upstream, "frames.rs"), "paced frames\n");patch("zed-idle-frames.patch");+ writeFileSync(path.join(upstream, "atlas.rs"), "streaming images\n");+ patch("zed-streaming-image.patch");const script = path.join(cap, "scripts/prepare-gpui-dependency.sh");writeFileSync(script,@@ -165,6 +168,10 @@ test("dependency verification handles overlapping patches without changing the creadFileSync(path.join(zed, "frames.rs"), "utf8"),"paced frames\n",);+ assert.equal(+ readFileSync(path.join(zed, "atlas.rs"), "utf8"),+ "streaming images\n",+ );});writeFileSync(path.join(zed, "unrelated.txt"), "preserve staged work\n");